HexDumpBytes (OpenHFT/Chronicle-Bytes 2.23ea25 API)

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

All Implemented Interfaces:

Appendable, CharSequence, Bytes<Void>, BytesComment<BytesOut<Void>>, BytesIn<Void>, BytesOut<Void>, BytesPrepender<Bytes<Void>>, BytesStore<Bytes<Void>,Void>, ByteStringAppender<Bytes<Void>>, ByteStringParser<Bytes<Void>>, RandomDataInput, RandomDataOutput<Bytes<Void>>, 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>
```

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

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

Constructor Summary

Constructors
Constructor and Description

HexDumpBytes()

Constructors
Constructor and Description
`HexDumpBytes()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`long`	`addressForRead(long offset)` Obtain the underlying addressForRead.
`long`	`addressForWrite(long offset)` Obtain the underlying addressForRead.
`long`	`addressForWritePosition()`
`@NotNull BytesStore`	`bytesStore()` Returns the backing ByteStore this Bytes object wraps, or null.
`long`	`capacity()`
`@NotNull Bytes<Void>`	`clear()` Set the readPosition= writePosition = start, writeLimit = capacity
`@NotNull Bytes<Void>`	`clearAndPad(long length)` Clear a buffer, with a given padding to allow for prepending later.
`Bytes<Void>`	`comment(@NotNull CharSequence comment)` Add comment as appropriate for the toHexString format
`@NotNull Bytes<Void>`	`compact()` Compact these Bytes by moving the readPosition to the start.
`boolean`	`compareAndSwapInt(long offset, int expected, int value)` Perform a 32-bit CAS at a given offset.
`boolean`	`compareAndSwapLong(long offset, long expected, long value)` Perform a 64-bit CAS at a given offset.
`BytesStore`	`copy()` Creates and returns a new copy of this Bytes object from `RandomCommon.readPosition()` to `RandomCommon.readLimit()`.
`void`	`ensureCapacity(long desiredCapacity)` Grows the buffer if the buffer is elastic, if the buffer is not elastic and there is not enough capacity then this method will throw an `DecoratedBufferOverflowException`
`boolean`	`equals(Object obj)`
`static HexDumpBytes`	`fromText(@NotNull CharSequence text)`
`static HexDumpBytes`	`fromText(@NotNull Reader reader)`
`int`	`hashCode()`
`BytesOut<Void>`	`indent(int n)` Adjust the indent for nested data
`boolean`	`isDirectMemory()`
`boolean`	`isElastic()` Returns if this Bytes object is elastic.
`int`	`lastDecimalPlaces()`
`void`	`lastDecimalPlaces(int lastDecimalPlaces)` Store the last number of decimal places.
`boolean`	`lastNumberHadDigits()`
`void`	`lastNumberHadDigits(boolean lastNumberHadDigits)`
`long`	`lengthWritten(long startPosition)` Typically this calculates the difference however for HexDumpBytes it's not as simple.
`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)`
`void`	`nativeRead(long position, long address, long size)` expert level method for copying data to native memory.
`void`	`nativeWrite(long address, long position, long size)` expert level method to copy data from native memory into the BytesStore
`int`	`numberWrap()`
`HexDumpBytes`	`numberWrap(int numberWrap)`
`HexDumpBytes`	`offsetFormat(OffsetFormat offsetFormat)`
`int`	`peekUnsignedByte()`
`int`	`peekUnsignedByte(long offset)` Read an unsigned byte at an offset, or -1
`@NotNull Bytes<Void>`	`prewrite(byte[] bytes)` Write backward in binary a byte
`@NotNull Bytes<Void>`	`prewrite(BytesStore bytes)` Write backward in binary a byte
`@NotNull Bytes<Void>`	`prewriteByte(byte b)` Write backward in binary a byte
`@NotNull Bytes<Void>`	`prewriteInt(int i)` Write backward in binary a 4 byte int
`@NotNull Bytes<Void>`	`prewriteLong(long l)` Write backward in binary an 8 byte long
`@NotNull Bytes<Void>`	`prewriteShort(short i)` Write backward in binary a 2 byte int
`int`	`read(byte[] bytes)`
`int`	`read(byte[] bytes, int off, int len)`
`void`	`read(@NotNull ByteBuffer buffer)`
`void`	`read(@NotNull Bytes<?> bytes, int length)`
`int`	`read(char[] bytes, int off, int len)`
`@Nullable String`	`read8bit()`
`boolean`	`read8bit(@NotNull Bytes<?> b)`
`boolean`	`read8bit(@NotNull StringBuilder sb)`
`@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()`
`byte`	`readByte()`
`byte`	`readByte(long offset)` Read byte at an offset
`double`	`readDouble()`
`double`	`readDouble(long offset)` Read a double at an offset
`<E extends Enum<E>> E`	`readEnum(@NotNull Class<E> eClass)`
`float`	`readFloat()`
`float`	`readFloat(long offset)` Read a float at an offset
`void`	`readHistogram(@NotNull net.openhft.chronicle.core.util.Histogram histogram)`
`int`	`readInt()`
`int`	`readInt(long offset)` Read an int at an offset
`int`	`readInt24()`
`long`	`readLimit()` If the resource is closed, the returned value is unspecified.
`@NotNull Bytes<Void>`	`readLimit(long limit)`
`long`	`readLong()`
`long`	`readLong(long offset)` Read a long at an offset
`<T extends ReadBytesMarshallable> T`	`readMarshallableLength16(@NotNull Class<T> clazz, T using)` Reads the content of this Bytes object converting it to an object of the provided `clazz` using the provided `using`, or if `null` is provided for `using`, creates a new object, eventually returning whichever object was updated.
`long`	`readPosition()` Returns the read position.
`@NotNull Bytes<Void>`	`readPosition(long position)`
`@NotNull Bytes<Void>`	`readPositionRemaining(long position, long remaining)`
`@NotNull Bytes<Void>`	`readPositionUnlimited(long position)`
`long`	`readRemaining()` Returns the remaining bytes that can be read.
`short`	`readShort()`
`short`	`readShort(long offset)` Read a short at an offset
`@NotNull Bytes<Void>`	`readSkip(long bytesToSkip)` Skip a number of bytes by moving the readPosition.
`long`	`readStopBit()`
`char`	`readStopBitChar()`
`double`	`readStopBitDecimal()`
`double`	`readStopBitDouble()`
`int`	`readUnsignedByte()`
`long`	`readUnsignedInt()`
`int`	`readUnsignedInt24()`
`int`	`readUnsignedShort()`
`@Nullable String`	`readUtf8()` The same as readUTF() except the length is stop bit encoded.
`<C extends Appendable & CharSequence> boolean`	`readUtf8(C sb)` The same as readUtf8() except the chars are copied to a truncated StringBuilder.
`<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.
`<C extends Appendable & CharSequence> boolean`	`readUTFΔ(C sb)`
`byte`	`readVolatileByte(long offset)` Read a 8-bit byte from memory with a load barrier.
`int`	`readVolatileInt()`
`int`	`readVolatileInt(long offset)` Read a 32-bit int from memory with a load barrier.
`long`	`readVolatileLong()`
`long`	`readVolatileLong(long offset)` Read a 64-bit long from memory with a load barrier.
`short`	`readVolatileShort(long offset)` Read a 16-bit short from memory with a load barrier.
`void`	`readWithLength(@NotNull Bytes<?> bytes)`
`void`	`readWithLength(long length, @NotNull BytesOut<Void> bytesOut)` Writes the content of this Bytes object into the provided `bytesOut` writing the provided `length` bytes.
`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 with 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 with 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`	`reserve(net.openhft.chronicle.core.io.ReferenceOwner owner)`
`boolean`	`reservedBy(net.openhft.chronicle.core.io.ReferenceOwner owner)`
`boolean`	`retainsComments()` Do these Bytes support saving comments as descriptions for fields.
`void`	`singleThreadedCheckDisabled(boolean singleThreadedCheckDisabled)`
`void`	`singleThreadedCheckReset()`
`void`	`testAndSetInt(long offset, int expected, int value)`
`@NotNull String`	`toHexString()` Creates and returns a new String representing the contents of this Bytes object in hexadecimal form encoding at most 1024 bytes.
`@NotNull String`	`toString()`
`boolean`	`tryReserve(net.openhft.chronicle.core.io.ReferenceOwner owner)`
`void`	`uncheckedReadSkipBackOne()` Read skip -1 when you are sure this is safe.
`void`	`uncheckedReadSkipOne()` Read skip 1 when you are sure this is safe.
`int`	`uncheckedReadUnsignedByte()`
`@Nullable Void`	`underlyingObject()`
`@NotNull Bytes<Void>`	`write(byte[] byteArray)` Write all data or fail.
`@NotNull Bytes<Void>`	`write(byte[] byteArray, int offset, int length)` Writes all data from the provided `byteArray` into this Bytes object.
`Bytes<Void>`	`write(@NotNull BytesStore<?,?> bytes)` Writes all the passed BytesStore or it fails.
`@NotNull Bytes<Void>`	`write(@NotNull BytesStore bytes, long offset, long length)` Write all data or fail.
`@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` to the contents of 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)` Copy from ByteBuffer into this.
`@NotNull Bytes<Void>`	`write(long writeOffset, @NotNull RandomDataInput bytes, long readOffset, long length)` Copy from RandomDataInput into this.
`@NotNull Bytes<Void>`	`write(@NotNull RandomDataInput bytes)` Write all data or fail.
`@NotNull Bytes<Void>`	`write(@NotNull RandomDataInput bytes, long offset, long length)` Write all data or fail.
`@NotNull Bytes<Void>`	`write8bit(@Nullable BytesStore bs)`
`@NotNull Bytes<Void>`	`write8bit(@Nullable CharSequence text)`
`@NotNull Bytes<Void>`	`write8bit(@NotNull CharSequence text, int start, int length)`
`long`	`write8bit(long position, @NotNull BytesStore bs)` Write the stop bit length and copy the BytesStore
`long`	`write8bit(long position, @NotNull String s, int start, int length)`
`@NotNull Bytes<Void>`	`write8bit(@Nullable String s)`
`@NotNull Bytes<Void>`	`write8bit(@NotNull String text, int start, int length)`
`void`	`writeBigDecimal(@NotNull BigDecimal bd)`
`void`	`writeBigInteger(@NotNull BigInteger bi)`
`@NotNull Bytes<Void>`	`writeBoolean(boolean flag)`
`@NotNull Bytes<Void>`	`writeByte(byte i8)`
`@NotNull Bytes<Void>`	`writeByte(long offset, byte i8)` Write an unsigned byte at an offset.
`@NotNull Bytes<Void>`	`writeDouble(double d)`
`@NotNull Bytes<Void>`	`writeDouble(long offset, double d)` Write a double at an offset.
`@NotNull Bytes<Void>`	`writeDoubleAndInt(double d, int i)`
`<E extends Enum<E>> Bytes<Void>`	`writeEnum(E e)`
`@NotNull Bytes<Void>`	`writeFloat(float f)`
`@NotNull Bytes<Void>`	`writeFloat(long offset, float d)` Write a float at an offset.
`void`	`writeHistogram(@NotNull net.openhft.chronicle.core.util.Histogram histogram)`
`@NotNull Bytes<Void>`	`writeInt(int i)`
`@NotNull Bytes<Void>`	`writeInt(long offset, int i)` Write an int at an offset.
`@NotNull Bytes<Void>`	`writeInt24(int i)`
`@NotNull Bytes<Void>`	`writeInt24(long offset, int i)`
`@NotNull Bytes<Void>`	`writeIntAdv(int i, int advance)`
`long`	`writeLimit()` Returns the write limit.
`@NotNull Bytes<Void>`	`writeLimit(long limit)`
`@NotNull Bytes<Void>`	`writeLong(long i64)` Write a long
`@NotNull Bytes<Void>`	`writeLong(long offset, long i)` Write a long at an offset.
`@NotNull Bytes<Void>`	`writeLongAdv(long i64, int advance)`
`void`	`writeMarshallableLength16(@NotNull WriteBytesMarshallable marshallable)` Writes the content of the provided `marshallable` to this Bytes object converting from an object to a number of bytes.
`@NotNull Bytes<Void>`	`writeOrderedInt(int i)`
`@NotNull Bytes<Void>`	`writeOrderedInt(long offset, int i)` Perform a non stalling write with a store barrier.
`@NotNull Bytes<Void>`	`writeOrderedLong(long i)`
`@NotNull Bytes<Void>`	`writeOrderedLong(long offset, long i)` Perform a non stalling write with a store barrier.
`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)`
`void`	`writePositionRemaining(long position, long length)`
`long`	`writeRemaining()` If the resource is closed, the returned value is unspecified.
`@NotNull Bytes<Void>`	`writeShort(long offset, short i)` Write a short at an offset.
`@NotNull Bytes<Void>`	`writeShort(short i16)`
`@NotNull Bytes<Void>`	`writeSkip(long bytesToSkip)` Skip a number of bytes by moving the writePosition.
`@NotNull Bytes<Void>`	`writeSome(@NotNull ByteBuffer buffer)` Write all data available from buffer, constrained by how much space available in this.
`@NotNull Bytes<Void>`	`writeSome(@NotNull Bytes<?> bytes)` Write all data available from bytes argument, constrained by how much space available in this.
`@NotNull Bytes<Void>`	`writeStopBit(char x)`
`@NotNull Bytes<Void>`	`writeStopBit(double d)`
`@NotNull Bytes<Void>`	`writeStopBit(long x)` Write a stop bit encoded long
`@NotNull Bytes<Void>`	`writeStopBitDecimal(double d)`
`@NotNull Bytes<Void>`	`writeUnsignedByte(int i)`
`@NotNull Bytes<Void>`	`writeUnsignedInt(long i)`
`@NotNull Bytes<Void>`	`writeUnsignedInt24(int i)`
`@NotNull Bytes<Void>`	`writeUnsignedShort(int u16)`
`@NotNull Bytes<Void>`	`writeUtf8(@Nullable CharSequence text)` Write the same encoding as `writeUTF` with the following changes.
`@NotNull Bytes<Void>`	`writeUtf8(@Nullable String text)`
`@NotNull Bytes<Void>`	`writeVolatileByte(long offset, byte i8)`
`@NotNull Bytes<Void>`	`writeVolatileInt(long offset, int i32)`
`@NotNull Bytes<Void>`	`writeVolatileLong(long offset, long i64)`
`@NotNull Bytes<Void>`	`writeVolatileShort(long offset, short i16)`
`void`	`writeWithLength(@NotNull RandomDataInput bytes)`
`@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, 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.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, createCharToString, 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
append, append, append, append, append, append, append, append, append, append, append8bit, append8bit, append8bit, append8bit, append8bit, appendBase, appendBase16, appendBase16, appendDateMillis, appendDecimal, appendTimeMillis, writer

Methods inherited from interface net.openhft.chronicle.bytes.StreamingDataOutput
appendUtf8, appendUtf8, appendUtf8, appendUtf8, appendUtf8, appendUtf8, 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()
```

Method Detail

fromText

public static HexDumpBytes fromText(@NotNull
                                    @NotNull Reader reader)
                             throws NumberFormatException

Throws:: NumberFormatException

fromText

public static HexDumpBytes fromText(@NotNull
                                    @NotNull CharSequence text)
                             throws NumberFormatException

Throws:: NumberFormatException

offsetFormat

public HexDumpBytes offsetFormat(OffsetFormat offsetFormat)

numberWrap
```
public int numberWrap()
```

numberWrap

public HexDumpBytes numberWrap(int numberWrap)

readRemaining
```
public long readRemaining()
```
Returns the remaining bytes that can be read.
If the resource is closed, the returned value is unspecified.

Returns:

How many more bytes can we read.

writeRemaining
```
public long writeRemaining()
```
If the resource is closed, the returned value is unspecified.

Returns:

How many more bytes can we 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()
```
Returns the write limit.
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 encoding at most 1024 bytes.

Specified by:

toHexString in interface Bytes<Void>

Returns:

a new hex String

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

retainsComments
```
public boolean retainsComments()
```
Description copied from interface: BytesComment

Do these Bytes support saving comments as descriptions for fields.

Specified by:

retainsComments in interface BytesComment<BytesOut<Void>>

Returns:

true if comments are for field descriptions

comment
```
public Bytes<Void> comment(@NotNull
                           @NotNull CharSequence comment)
                    throws IllegalStateException
```
Description copied from interface: BytesComment

Add comment as appropriate for the toHexString format

Specified by:

comment in interface BytesComment<BytesOut<Void>>

Parameters:

comment - to add (or ignore)

Returns:

this

Throws:

IllegalStateException

indent
```
public BytesOut<Void> indent(int n)
                      throws IllegalStateException
```
Description copied from interface: BytesComment

Adjust the indent for nested data

Specified by:

indent in interface BytesComment<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 new copy of this Bytes object from RandomCommon.readPosition() to RandomCommon.readLimit().

Specified by:

copy in interface Bytes<Void>

Specified by:

copy in interface BytesStore<Bytes<Void>,Void>

Returns:

a copy of this Bytes object

isElastic
```
public boolean isElastic()
```
Description copied from interface: Bytes

Returns if this Bytes object is elastic. I.e. it can resize when more data is written than it's Bytes.realCapacity().

Specified by:

isElastic in interface Bytes<Void>

Returns:

if this Bytes object is elastic

ensureCapacity
```
public void ensureCapacity(long desiredCapacity)
                    throws IllegalArgumentException,
                           IllegalStateException
```
Description copied from interface: Bytes

Grows the buffer if the buffer is elastic, if the buffer is not elastic and there is not enough capacity then this method will throw an DecoratedBufferOverflowException

Specified by:

ensureCapacity in interface Bytes<Void>

Parameters:

desiredCapacity - the capacity that you required

Throws:

IllegalStateException - if closed and it needs a resize

IllegalArgumentException

bytesStore
```
@NotNull
public @NotNull BytesStore bytesStore()
```
Description copied from interface: Bytes

Returns the backing ByteStore this Bytes object wraps, or null.

Specified by:

bytesStore in interface Bytes<Void>

Specified by:

bytesStore in interface BytesStore<Bytes<Void>,Void>

Returns:

the backing ByteStore

compact
```
@NotNull
public @NotNull Bytes<Void> compact()
```
Description copied from interface: Bytes

Compact these Bytes by moving the readPosition to the start.

Specified by:

compact in interface Bytes<Void>

Returns:

this Bytes object

clear
```
@NotNull
public @NotNull Bytes<Void> clear()
                                    throws IllegalStateException
```
Description copied from interface: StreamingCommon

Set the readPosition= writePosition = start, writeLimit = capacity

Specified by:

clear in interface Bytes<Void>

Specified by:

clear in interface StreamingCommon<Bytes<Void>>

Returns:

this

Throws:

IllegalStateException - if this resource has been previously released

isDirectMemory
```
public boolean isDirectMemory()
```
Specified by:

isDirectMemory in interface BytesStore<Bytes<Void>,Void>

Returns:

whether it uses direct memory or not.

capacity
```
public long capacity()
```
Specified by:

capacity in interface BytesStore<Bytes<Void>,Void>

Returns:

The maximum limit you can set.

addressForRead
```
public long addressForRead(long offset)
                    throws UnsupportedOperationException,
                           IllegalStateException,
                           BufferUnderflowException
```
Obtain the underlying addressForRead. This is for expert users only.

Parameters:

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

Returns:

the underlying addressForRead of the buffer

Throws:

UnsupportedOperationException - if the underlying buffer is on the heap

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

IllegalStateException

addressForWrite
```
public long addressForWrite(long offset)
                     throws UnsupportedOperationException
```
Obtain the underlying addressForRead. This is for expert users only.

Parameters:

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

Returns:

the underlying addressForRead of the buffer

Throws:

UnsupportedOperationException - if the underlying buffer is on the heap

addressForWritePosition

public long addressForWritePosition()
                             throws UnsupportedOperationException,
                                    BufferOverflowException

Throws:: UnsupportedOperationException; BufferOverflowException

compareAndSwapInt
```
public boolean compareAndSwapInt(long offset,
                                 int expected,
                                 int value)
                          throws BufferOverflowException,
                                 IllegalStateException
```
Description copied from interface: RandomDataInput

Perform a 32-bit CAS at a given offset.

Specified by:

compareAndSwapInt in interface BytesStore<Bytes<Void>,Void>

Specified by:

compareAndSwapInt in interface RandomDataInput

Specified by:

compareAndSwapInt in interface RandomDataOutput<Bytes<Void>>

Parameters:

offset - to perform CAS

expected - value

value - to set

Returns:

true, if successful.

Throws:

BufferOverflowException

IllegalStateException

testAndSetInt

public void testAndSetInt(long offset,
                          int expected,
                          int value)
                   throws IllegalStateException,
                          BufferOverflowException

Specified by:: testAndSetInt in interface RandomDataInput
Specified by:: testAndSetInt in interface RandomDataOutput<Bytes<Void>>
Throws:: IllegalStateException; BufferOverflowException

compareAndSwapLong
```
public boolean compareAndSwapLong(long offset,
                                  long expected,
                                  long value)
                           throws BufferOverflowException,
                                  IllegalStateException
```
Description copied from interface: RandomDataInput

Perform a 64-bit CAS at a given offset.

Specified by:

compareAndSwapLong in interface BytesStore<Bytes<Void>,Void>

Specified by:

compareAndSwapLong in interface RandomDataInput

Specified by:

compareAndSwapLong in interface RandomDataOutput<Bytes<Void>>

Parameters:

offset - to perform CAS

expected - value

value - to set

Returns:

true, if successful.

Throws:

BufferOverflowException

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)

Specified by:: move in interface BytesStore<Bytes<Void>,Void>

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

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

reservedBy

public boolean reservedBy(net.openhft.chronicle.core.io.ReferenceOwner owner)
                   throws IllegalStateException

Specified by:: reservedBy in interface net.openhft.chronicle.core.io.ReferenceCounted
Throws:: IllegalStateException

writeByte

@NotNull
public @NotNull Bytes<Void> writeByte(long offset,
                                               byte i8)
                                        throws BufferOverflowException,
                                               IllegalStateException

Description copied from interface: RandomDataOutput

Write an unsigned byte at an offset.

Specified by:: writeByte in interface RandomDataOutput<Bytes<Void>>
Parameters:: offset - to write to; i8 - the value
Returns:: this
Throws:: BufferOverflowException - if the capacity was exceeded; IllegalStateException

writeShort

@NotNull
public @NotNull Bytes<Void> writeShort(long offset,
                                                short i)
                                         throws BufferOverflowException,
                                                IllegalStateException

Description copied from interface: RandomDataOutput

Write a short at an offset.

Specified by:: writeShort in interface RandomDataOutput<Bytes<Void>>
Parameters:: offset - to write to; i - the value
Returns:: this
Throws:: BufferOverflowException - if the capacity was exceeded; IllegalStateException

writeInt24

@NotNull
public @NotNull Bytes<Void> writeInt24(long offset,
                                                int i)
                                         throws BufferOverflowException,
                                                IllegalStateException

Specified by:: writeInt24 in interface RandomDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalStateException

writeInt

@NotNull
public @NotNull Bytes<Void> writeInt(long offset,
                                              int i)
                                       throws BufferOverflowException,
                                              IllegalStateException

Description copied from interface: RandomDataOutput

Write an int at an offset.

Specified by:: writeInt in interface RandomDataOutput<Bytes<Void>>
Parameters:: offset - to write to; i - the value
Returns:: this
Throws:: BufferOverflowException - if the capacity was exceeded; IllegalStateException

writeOrderedInt

@NotNull
public @NotNull Bytes<Void> writeOrderedInt(long offset,
                                                     int i)
                                              throws BufferOverflowException,
                                                     IllegalStateException

Description copied from interface: RandomDataOutput

Perform a non stalling write with a store barrier.

Specified by:: writeOrderedInt in interface RandomDataOutput<Bytes<Void>>
Parameters:: offset - to write to; i - value to write
Returns:: this
Throws:: BufferOverflowException - if the capacity was exceeded; IllegalStateException

writeLong

@NotNull
public @NotNull Bytes<Void> writeLong(long offset,
                                               long i)
                                        throws BufferOverflowException,
                                               IllegalStateException

Description copied from interface: RandomDataOutput

Write a long at an offset.

Specified by:: writeLong in interface RandomDataOutput<Bytes<Void>>
Parameters:: offset - to write to; i - the value
Returns:: this
Throws:: BufferOverflowException - if the capacity was exceeded; IllegalStateException

writeOrderedLong

@NotNull
public @NotNull Bytes<Void> writeOrderedLong(long offset,
                                                      long i)
                                               throws BufferOverflowException,
                                                      IllegalStateException

Description copied from interface: RandomDataOutput

Perform a non stalling write with a store barrier.

Specified by:: writeOrderedLong in interface RandomDataOutput<Bytes<Void>>
Parameters:: offset - to write to; i - value to write
Returns:: this
Throws:: BufferOverflowException; IllegalStateException

writeFloat

@NotNull
public @NotNull Bytes<Void> writeFloat(long offset,
                                                float d)
                                         throws BufferOverflowException,
                                                IllegalStateException

Description copied from interface: RandomDataOutput

Write a float at an offset.

Specified by:: writeFloat in interface RandomDataOutput<Bytes<Void>>
Parameters:: offset - to write to; d - the value
Returns:: this
Throws:: BufferOverflowException - if the capacity was exceeded; IllegalStateException

writeDouble

@NotNull
public @NotNull Bytes<Void> writeDouble(long offset,
                                                 double d)
                                          throws BufferOverflowException,
                                                 IllegalStateException

Description copied from interface: RandomDataOutput

Write a double at an offset.

Specified by:: writeDouble in interface RandomDataOutput<Bytes<Void>>
Parameters:: offset - to write to; d - the value
Returns:: this
Throws:: BufferOverflowException - if the capacity was exceeded; IllegalStateException

writeVolatileByte

@NotNull
public @NotNull Bytes<Void> writeVolatileByte(long offset,
                                                       byte i8)
                                                throws BufferOverflowException

Specified by:: writeVolatileByte in interface RandomDataOutput<Bytes<Void>>
Throws:: BufferOverflowException

writeVolatileShort

@NotNull
public @NotNull Bytes<Void> writeVolatileShort(long offset,
                                                        short i16)
                                                 throws BufferOverflowException

Specified by:: writeVolatileShort in interface RandomDataOutput<Bytes<Void>>
Throws:: BufferOverflowException

writeVolatileInt

@NotNull
public @NotNull Bytes<Void> writeVolatileInt(long offset,
                                                      int i32)
                                               throws BufferOverflowException

Specified by:: writeVolatileInt in interface RandomDataOutput<Bytes<Void>>
Throws:: BufferOverflowException

writeVolatileLong

@NotNull
public @NotNull Bytes<Void> writeVolatileLong(long offset,
                                                       long i64)
                                                throws BufferOverflowException

Specified by:: writeVolatileLong in interface RandomDataOutput<Bytes<Void>>
Throws:: BufferOverflowException

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 - non-negative offset to write to

byteArray - non-null copy from byteArray

offset - non-negative copy from offset

length - non-negative length to copy

Returns:

this

write
```
public void write(long offsetInRDO,
                  @NotNull
                  @NotNull ByteBuffer bytes,
                  int offset,
                  int length)
```
Description copied from interface: RandomDataOutput

Copy from ByteBuffer into this.
Does not update cursors e.g. writePosition()

Specified by:

write in interface RandomDataOutput<Bytes<Void>>

Parameters:

offsetInRDO - offset to write to

bytes - copy from bytes

offset - copy from offset

write

@NotNull
public @NotNull Bytes<Void> write(long writeOffset,
                                           @NotNull
                                           @NotNull RandomDataInput bytes,
                                           long readOffset,
                                           long length)

Description copied from interface: RandomDataOutput

Copy from RandomDataInput into this. Does not bump writePosition() nor RandomCommon.readPosition()

Specified by:: write in interface RandomDataOutput<Bytes<Void>>
Parameters:: writeOffset - offset to write to; bytes - copy from bytes; readOffset - copy from offset
Returns:: this

write8bit
```
public long write8bit(long position,
                      @NotNull
                      @NotNull BytesStore bs)
```
Description copied from interface: RandomDataOutput

Write the stop bit length and copy the BytesStore

Specified by:

write8bit in interface RandomDataOutput<Bytes<Void>>

Parameters:

position - to write

bs - to copy.

Returns:

the offset after the char sequence written, in this RandomDataOutput

write8bit

public long write8bit(long position,
                      @NotNull
                      @NotNull String s,
                      int start,
                      int length)

Specified by:: write8bit in interface RandomDataOutput<Bytes<Void>>

nativeWrite
```
public void nativeWrite(long address,
                        long position,
                        long size)
```
Description copied from interface: RandomDataOutput

expert level method to copy data from native memory into the BytesStore

Specified by:

nativeWrite in interface RandomDataOutput<Bytes<Void>>

Parameters:

address - in native memory to copy from

position - in BytesStore to copy to

size - in bytes

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:

IllegalStateException

readPosition

@NotNull
public @NotNull Bytes<Void> readPosition(long position)
                                           throws BufferUnderflowException,
                                                  IllegalStateException

Specified by:: readPosition in interface StreamingDataInput<Bytes<Void>>
Throws:: BufferUnderflowException; IllegalStateException

readLimit

@NotNull
public @NotNull Bytes<Void> readLimit(long limit)
                                        throws BufferUnderflowException

Specified by:: readLimit in interface StreamingDataInput<Bytes<Void>>
Throws:: BufferUnderflowException

readSkip
```
@NotNull
public @NotNull Bytes<Void> readSkip(long bytesToSkip)
                                       throws BufferUnderflowException,
                                              IllegalStateException
```
Description copied from interface: StreamingDataInput

Skip a number of bytes by moving the readPosition. Must be less than or equal to the readLimit.

Specified by:

readSkip in interface StreamingDataInput<Bytes<Void>>

Parameters:

bytesToSkip - bytes to skip.

Returns:

this

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

IllegalStateException

uncheckedReadSkipOne
```
public void uncheckedReadSkipOne()
```
Description copied from interface: StreamingDataInput

Read skip 1 when you are sure this is safe. Use at your own risk when you find a performance problem.

Specified by:

uncheckedReadSkipOne in interface StreamingDataInput<Bytes<Void>>

uncheckedReadSkipBackOne
```
public void uncheckedReadSkipBackOne()
```
Description copied from interface: StreamingDataInput

Read skip -1 when you are sure this is safe. Use at your own risk when you find a performance problem.

Specified by:

uncheckedReadSkipBackOne in interface StreamingDataInput<Bytes<Void>>

readStopBit

public long readStopBit()
                 throws net.openhft.chronicle.core.io.IORuntimeException,
                        IllegalStateException,
                        BufferUnderflowException

Specified by:: readStopBit in interface StreamingDataInput<Bytes<Void>>
Throws:: net.openhft.chronicle.core.io.IORuntimeException; IllegalStateException; BufferUnderflowException

readStopBitChar

public char readStopBitChar()
                     throws net.openhft.chronicle.core.io.IORuntimeException,
                            IllegalStateException,
                            BufferUnderflowException

Specified by:: readStopBitChar in interface StreamingDataInput<Bytes<Void>>
Throws:: net.openhft.chronicle.core.io.IORuntimeException; IllegalStateException; BufferUnderflowException

readStopBitDouble
```
public double readStopBitDouble()
                         throws IllegalStateException
```
Specified by:

readStopBitDouble in interface StreamingDataInput<Bytes<Void>>

Throws:

IllegalStateException

readStopBitDecimal

public double readStopBitDecimal()
                          throws IllegalStateException,
                                 BufferUnderflowException

Specified by:: readStopBitDecimal in interface StreamingDataInput<Bytes<Void>>
Throws:: IllegalStateException; BufferUnderflowException

readByte
```
public byte readByte()
              throws IllegalStateException
```
Specified by:

readByte in interface StreamingDataInput<Bytes<Void>>

Throws:

IllegalStateException

readUnsignedByte
```
public int readUnsignedByte()
                     throws IllegalStateException
```
Specified by:

readUnsignedByte in interface StreamingDataInput<Bytes<Void>>

Returns:

the next unsigned 8 bit value or -1;

Throws:

IllegalStateException

uncheckedReadUnsignedByte
```
public int uncheckedReadUnsignedByte()
```
Specified by:

uncheckedReadUnsignedByte in interface StreamingDataInput<Bytes<Void>>

Returns:

the next unsigned 8 bit value or -1;

readShort

public short readShort()
                throws BufferUnderflowException,
                       IllegalStateException

Specified by:: readShort in interface StreamingDataInput<Bytes<Void>>
Throws:: BufferUnderflowException; IllegalStateException

readInt

public int readInt()
            throws BufferUnderflowException,
                   IllegalStateException

Specified by:: readInt in interface StreamingDataInput<Bytes<Void>>
Throws:: BufferUnderflowException; IllegalStateException

readLong

public long readLong()
              throws BufferUnderflowException,
                     IllegalStateException

Specified by:: readLong in interface StreamingDataInput<Bytes<Void>>
Throws:: BufferUnderflowException; IllegalStateException

readFloat

public float readFloat()
                throws BufferUnderflowException,
                       IllegalStateException

Specified by:: readFloat in interface StreamingDataInput<Bytes<Void>>
Throws:: BufferUnderflowException; IllegalStateException

readDouble

public double readDouble()
                  throws BufferUnderflowException,
                         IllegalStateException

Specified by:: readDouble in interface StreamingDataInput<Bytes<Void>>
Throws:: BufferUnderflowException; IllegalStateException

readVolatileInt

public int readVolatileInt()
                    throws BufferUnderflowException,
                           IllegalStateException

Specified by:: readVolatileInt in interface StreamingDataInput<Bytes<Void>>
Throws:: BufferUnderflowException; IllegalStateException

readVolatileLong

public long readVolatileLong()
                      throws BufferUnderflowException,
                             IllegalStateException

Specified by:: readVolatileLong in interface StreamingDataInput<Bytes<Void>>
Throws:: BufferUnderflowException; IllegalStateException

peekUnsignedByte
```
public int peekUnsignedByte()
                     throws IllegalStateException
```
Specified by:

peekUnsignedByte in interface StreamingDataInput<Bytes<Void>>

Throws:

IllegalStateException

lastDecimalPlaces
```
public int lastDecimalPlaces()
```
Specified by:

lastDecimalPlaces in interface ByteStringParser<Bytes<Void>>

Returns:

the last number of decimal places for parseDouble or parseLongDecimal

lastDecimalPlaces
```
public void lastDecimalPlaces(int lastDecimalPlaces)
```
Description copied from interface: ByteStringParser

Store the last number of decimal places. If

Specified by:

lastDecimalPlaces in interface ByteStringParser<Bytes<Void>>

Parameters:

lastDecimalPlaces - set the number of decimal places if positive, otherwise 0.

lastNumberHadDigits
```
public boolean lastNumberHadDigits()
```
Specified by:

lastNumberHadDigits in interface ByteStringParser<Bytes<Void>>

Returns:

the last number had digits

lastNumberHadDigits
```
public void lastNumberHadDigits(boolean lastNumberHadDigits)
```
Specified by:

lastNumberHadDigits in interface ByteStringParser<Bytes<Void>>

Parameters:

lastNumberHadDigits - set the last number had digits

readBigDecimal
```
@NotNull
public @NotNull BigDecimal readBigDecimal()
                                            throws BufferUnderflowException,
                                                   ArithmeticException,
                                                   IllegalStateException
```
Description copied from interface: Bytes

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

IllegalStateException - if this Bytes object was previously released

readBigInteger
```
@NotNull
public @NotNull BigInteger readBigInteger()
                                            throws BufferUnderflowException,
                                                   ArithmeticException,
                                                   IllegalStateException
```
Description copied from interface: Bytes

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

IllegalStateException - if this Bytes object was previously released

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 content of this Bytes object into the provided bytesOut writing the provided length bytes.
The readLimit and readPosition is not affected by this operation.

Specified by:

readWithLength in interface Bytes<Void>

Parameters:

length - indicating the number of bytes to write

bytesOut - non-null target to write the content of this Bytes object to

Throws:

BufferUnderflowException - if the provided length is greater than the remaining bytes readable.

net.openhft.chronicle.core.io.IORuntimeException - if there is an error reading or writing data

IllegalStateException - if this Bytes object or the provided bytesOut has been previously released.

BufferOverflowException - if the provided bytesOut cannot hold the bytes to be written

readMarshallableLength16
```
public <T extends ReadBytesMarshallable> T readMarshallableLength16(@NotNull
                                                                    @NotNull Class<T> clazz,
                                                                    @Nullable
                                                                    T using)
                                                             throws BufferUnderflowException,
                                                                    IllegalStateException
```
Description copied from interface: Bytes

Reads the content of this Bytes object converting it to an object of the provided clazz using the provided using, or if null is provided for using, creates a new object, eventually returning whichever object was updated.
The content of this Bytes object is assumed to have a 16-bit length indicator preceding the actual object.

Specified by:

readMarshallableLength16 in interface Bytes<Void>

Specified by:

readMarshallableLength16 in interface BytesIn<Void>

Type Parameters:

T - type of the provided using

Parameters:

clazz - non-null type to read

using - to update, nullable

Returns:

An object that was read from this Bytes object

Throws:

BufferUnderflowException - if the content of this Bytes object is insufficient.

IllegalStateException - if this Bytes object or the provided bytesOut has been previously released.

See Also:

Bytes.writeMarshallableLength16(WriteBytesMarshallable)

readPositionUnlimited

@NotNull
public @NotNull Bytes<Void> readPositionUnlimited(long position)
                                                    throws BufferUnderflowException,
                                                           IllegalStateException

Specified by:: readPositionUnlimited in interface StreamingDataInput<Bytes<Void>>
Throws:: BufferUnderflowException; IllegalStateException

readPositionRemaining

@NotNull
public @NotNull Bytes<Void> readPositionRemaining(long position,
                                                           long remaining)
                                                    throws BufferUnderflowException,
                                                           IllegalStateException

Specified by:: readPositionRemaining in interface StreamingDataInput<Bytes<Void>>
Throws:: BufferUnderflowException; 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 with a temporary bounds mode.

Specified by:: readWithLength0 in interface StreamingDataInput<Bytes<Void>>
Throws:: BufferUnderflowException; net.openhft.chronicle.core.io.IORuntimeException; 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 with a temporary bounds mode.

Specified by:: readWithLength in interface StreamingDataInput<Bytes<Void>>
Throws:: BufferUnderflowException; net.openhft.chronicle.core.io.IORuntimeException; IllegalStateException

readBoolean
```
public boolean readBoolean()
                    throws IllegalStateException
```
Specified by:

readBoolean in interface StreamingDataInput<Bytes<Void>>

Throws:

IllegalStateException

readUnsignedShort

public int readUnsignedShort()
                      throws BufferUnderflowException,
                             IllegalStateException

Specified by:: readUnsignedShort in interface StreamingDataInput<Bytes<Void>>
Throws:: BufferUnderflowException; IllegalStateException

readInt24

public int readInt24()
              throws BufferUnderflowException,
                     IllegalStateException

Specified by:: readInt24 in interface StreamingDataInput<Bytes<Void>>
Throws:: BufferUnderflowException; IllegalStateException

readUnsignedInt24

public int readUnsignedInt24()
                      throws BufferUnderflowException,
                             IllegalStateException

Specified by:: readUnsignedInt24 in interface StreamingDataInput<Bytes<Void>>
Throws:: BufferUnderflowException; IllegalStateException

readUnsignedInt

public long readUnsignedInt()
                     throws BufferUnderflowException,
                            IllegalStateException

Specified by:: readUnsignedInt in interface StreamingDataInput<Bytes<Void>>
Throws:: BufferUnderflowException; IllegalStateException

readUtf8
```
@Nullable
public @Nullable String readUtf8()
                                    throws BufferUnderflowException,
                                           net.openhft.chronicle.core.io.IORuntimeException,
                                           IllegalStateException,
                                           ArithmeticException
```
Description copied from interface: StreamingDataInput

The same as readUTF() except the length is stop bit encoded. This saves one byte for strings shorter than 128 chars. null values are also supported

Specified by:

readUtf8 in interface StreamingDataInput<Bytes<Void>>

Returns:

a Unicode string or null if writeUtf8(null) was called

Throws:

BufferUnderflowException

net.openhft.chronicle.core.io.IORuntimeException

IllegalStateException

ArithmeticException

read8bit

@Nullable
public @Nullable String read8bit()
                                    throws net.openhft.chronicle.core.io.IORuntimeException,
                                           BufferUnderflowException,
                                           IllegalStateException,
                                           ArithmeticException

Specified by:: read8bit in interface StreamingDataInput<Bytes<Void>>
Throws:: net.openhft.chronicle.core.io.IORuntimeException; BufferUnderflowException; IllegalStateException; ArithmeticException

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

The same as readUtf8() except the chars are copied to a truncated StringBuilder.

Specified by:: readUtf8 in interface StreamingDataInput<Bytes<Void>>
Parameters:: sb - to copy chars to
Returns:: true if there was a String, or false if it was null
Throws:: net.openhft.chronicle.core.io.IORuntimeException; IllegalArgumentException; BufferUnderflowException; IllegalStateException; ArithmeticException

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:

IllegalStateException - if released

net.openhft.chronicle.core.io.IORuntimeException

IllegalArgumentException

BufferUnderflowException

ArithmeticException

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, IllegalStateException 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:

IllegalStateException - if released

net.openhft.chronicle.core.io.IORuntimeException

IllegalArgumentException

BufferUnderflowException

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, IllegalStateException 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:

IllegalStateException - if released

BufferUnderflowException

net.openhft.chronicle.core.io.IORuntimeException

IllegalArgumentException

See Also:

RandomDataOutput.writeUtf8Limited(long, CharSequence, int)

readUTFΔ

public <C extends Appendable & CharSequence> boolean readUTFΔ(@NotNull
                                                              C sb)
                                                       throws net.openhft.chronicle.core.io.IORuntimeException,
                                                              IllegalArgumentException,
                                                              BufferUnderflowException,
                                                              IllegalStateException,
                                                              ArithmeticException

Throws:: net.openhft.chronicle.core.io.IORuntimeException; IllegalArgumentException; BufferUnderflowException; IllegalStateException; ArithmeticException

read8bit

public boolean read8bit(@NotNull
                        @NotNull Bytes<?> b)
                 throws BufferUnderflowException,
                        IllegalStateException,
                        BufferOverflowException,
                        ArithmeticException

Specified by:: read8bit in interface StreamingDataInput<Bytes<Void>>
Throws:: BufferUnderflowException; IllegalStateException; BufferOverflowException; ArithmeticException

read8bit

public boolean read8bit(@NotNull
                        @NotNull StringBuilder sb)
                 throws net.openhft.chronicle.core.io.IORuntimeException,
                        BufferUnderflowException,
                        ArithmeticException,
                        IllegalStateException

Specified by:: read8bit in interface StreamingDataInput<Bytes<Void>>
Throws:: net.openhft.chronicle.core.io.IORuntimeException; BufferUnderflowException; ArithmeticException; IllegalStateException

read

public int read(byte[] bytes)
         throws IllegalStateException,
                BufferUnderflowException

Specified by:: read in interface StreamingDataInput<Bytes<Void>>
Throws:: IllegalStateException; BufferUnderflowException

read

public int read(byte[] bytes,
                int off,
                int len)
         throws IllegalStateException,
                BufferUnderflowException

Specified by:: read in interface StreamingDataInput<Bytes<Void>>
Throws:: IllegalStateException; BufferUnderflowException

read

public int read(char[] bytes,
                int off,
                int len)
         throws IllegalStateException

Specified by:: read in interface StreamingDataInput<Bytes<Void>>
Throws:: IllegalStateException

read

public void read(@NotNull
                 @NotNull ByteBuffer buffer)
          throws IllegalStateException

Specified by:: read in interface StreamingDataInput<Bytes<Void>>
Throws:: IllegalStateException

read

public void read(@NotNull
                 @NotNull Bytes<?> bytes,
                 int length)
          throws BufferUnderflowException,
                 IllegalStateException,
                 BufferOverflowException

Specified by:: read in interface StreamingDataInput<Bytes<Void>>
Throws:: BufferUnderflowException; IllegalStateException; BufferOverflowException

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

Specified by:: readEnum in interface StreamingDataInput<Bytes<Void>>
Throws:: net.openhft.chronicle.core.io.IORuntimeException; BufferUnderflowException; IllegalStateException; ArithmeticException; BufferOverflowException

readHistogram

public void readHistogram(@NotNull
                          @NotNull net.openhft.chronicle.core.util.Histogram histogram)
                   throws BufferUnderflowException,
                          IllegalStateException,
                          ArithmeticException

Specified by:: readHistogram in interface StreamingDataInput<Bytes<Void>>
Throws:: BufferUnderflowException; IllegalStateException; ArithmeticException

readWithLength

public void readWithLength(@NotNull
                           @NotNull Bytes<?> bytes)
                    throws ArithmeticException,
                           BufferOverflowException,
                           IllegalStateException,
                           BufferUnderflowException

Specified by:: readWithLength in interface StreamingDataInput<Bytes<Void>>
Throws:: ArithmeticException; BufferOverflowException; IllegalStateException; BufferUnderflowException

writePosition

@NotNull
public @NotNull Bytes<Void> writePosition(long position)
                                            throws BufferOverflowException

Specified by:: writePosition in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException

writeLimit

@NotNull
public @NotNull Bytes<Void> writeLimit(long limit)
                                         throws BufferOverflowException

Specified by:: writeLimit in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException

writeSkip
```
@NotNull
public @NotNull Bytes<Void> writeSkip(long bytesToSkip)
                                        throws BufferOverflowException,
                                               IllegalStateException
```
Description copied from interface: StreamingDataOutput

Skip a number of bytes by moving the writePosition. Must be less than or equal to the writeLimit.

Specified by:

writeSkip in interface StreamingDataOutput<Bytes<Void>>

Parameters:

bytesToSkip - bytes to skip. This can be negative.

Returns:

this

Throws:

BufferOverflowException - if the offset is outside the limits of the Bytes

IllegalStateException

writeByte

@NotNull
public @NotNull Bytes<Void> writeByte(byte i8)
                                        throws BufferOverflowException,
                                               IllegalStateException

Specified by:: writeByte in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; 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)
```
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 - to compare against

Returns:

the length from the startPosition

writeShort

@NotNull
public @NotNull Bytes<Void> writeShort(short i16)
                                         throws BufferOverflowException,
                                                IllegalStateException

Specified by:: writeShort in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalStateException

writeInt

@NotNull
public @NotNull Bytes<Void> writeInt(int i)
                                       throws BufferOverflowException,
                                              IllegalStateException

Specified by:: writeInt in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalStateException

writeIntAdv

@NotNull
public @NotNull Bytes<Void> writeIntAdv(int i,
                                                 int advance)
                                          throws BufferOverflowException,
                                                 IllegalStateException

Specified by:: writeIntAdv in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalStateException

writeLong

@NotNull
public @NotNull Bytes<Void> writeLong(long i64)
                                        throws BufferOverflowException,
                                               IllegalStateException

Description copied from interface: StreamingDataOutput

Write a long

Specified by:: writeLong in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalStateException

writeLongAdv

@NotNull
public @NotNull Bytes<Void> writeLongAdv(long i64,
                                                  int advance)
                                           throws BufferOverflowException,
                                                  IllegalStateException

Specified by:: writeLongAdv in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalStateException

writeFloat

@NotNull
public @NotNull Bytes<Void> writeFloat(float f)
                                         throws BufferOverflowException,
                                                IllegalStateException

Specified by:: writeFloat in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalStateException

writeDouble

@NotNull
public @NotNull Bytes<Void> writeDouble(double d)
                                          throws BufferOverflowException,
                                                 IllegalStateException

Specified by:: writeDouble in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalStateException

writeDoubleAndInt

@NotNull
public @NotNull Bytes<Void> writeDoubleAndInt(double d,
                                                       int i)
                                                throws BufferOverflowException,
                                                       IllegalStateException

Specified by:: writeDoubleAndInt in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalStateException

write

@NotNull
public @NotNull Bytes<Void> write(byte[] byteArray,
                                           int offset,
                                           int length)
                                    throws BufferOverflowException,
                                           IllegalArgumentException,
                                           IllegalStateException

Description copied from interface: StreamingDataOutput

Writes all data from the provided byteArray into this Bytes object.

Invoking this method will update the cursors of this Bytes object.

Specified by:: write in interface StreamingDataOutput<Bytes<Void>>
Throws:: IllegalArgumentException - if the provided offset or length is negative; BufferOverflowException; IllegalStateException

writeSome

@NotNull
public @NotNull Bytes<Void> writeSome(@NotNull
                                               @NotNull ByteBuffer buffer)
                                        throws BufferOverflowException,
                                               IllegalStateException,
                                               BufferUnderflowException

Description copied from interface: StreamingDataOutput

Write all data available from buffer, constrained by how much space available in this.

Calling this method will update the cursors of this.

Specified by:: writeSome in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalStateException; BufferUnderflowException

writeOrderedInt

@NotNull
public @NotNull Bytes<Void> writeOrderedInt(int i)
                                              throws BufferOverflowException,
                                                     IllegalStateException

Specified by:: writeOrderedInt in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalStateException

writeOrderedLong

@NotNull
public @NotNull Bytes<Void> writeOrderedLong(long i)
                                               throws BufferOverflowException,
                                                      IllegalStateException

Specified by:: writeOrderedLong in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalStateException

clearAndPad
```
@NotNull
public @NotNull Bytes<Void> clearAndPad(long length)
                                          throws BufferOverflowException,
                                                 IllegalStateException
```
Description copied from interface: BytesPrepender

Clear a buffer, with a given padding to allow for prepending later. clearAndPad(0) is the same as clear()

Specified by:

clearAndPad in interface BytesPrepender<Bytes<Void>>

Parameters:

length - to pad

Returns:

this

Throws:

BufferOverflowException - if the length > capacity() - start()

IllegalStateException

prewrite
```
@NotNull
public @NotNull Bytes<Void> prewrite(byte[] bytes)
```
Description copied from interface: BytesPrepender

Write backward in binary a byte
Note: it moves the readPosition not the writePosition / readLimit

Specified by:

prewrite in interface BytesPrepender<Bytes<Void>>

Parameters:

bytes - to prepend to.

prewrite
```
@NotNull
public @NotNull Bytes<Void> prewrite(BytesStore bytes)
```
Description copied from interface: BytesPrepender

Write backward in binary a byte
Note: it moves the readPosition not the writePosition / readLimit

Specified by:

prewrite in interface BytesPrepender<Bytes<Void>>

Parameters:

bytes - to prepend to.

prewriteByte
```
@NotNull
public @NotNull Bytes<Void> prewriteByte(byte b)
```
Description copied from interface: BytesPrepender

Write backward in binary a byte
Note: it moves the readPosition not the writePosition / readLimit

Specified by:

prewriteByte in interface BytesPrepender<Bytes<Void>>

Parameters:

b - byte to prepend to.

prewriteShort
```
@NotNull
public @NotNull Bytes<Void> prewriteShort(short i)
```
Description copied from interface: BytesPrepender

Write backward in binary a 2 byte int
Note: it moves the readPosition not the writePosition / readLimit

Specified by:

prewriteShort in interface BytesPrepender<Bytes<Void>>

Parameters:

i - short to prepend to.

prewriteInt
```
@NotNull
public @NotNull Bytes<Void> prewriteInt(int i)
```
Description copied from interface: BytesPrepender

Write backward in binary a 4 byte int
Note: it moves the readPosition not the writePosition / readLimit

Specified by:

prewriteInt in interface BytesPrepender<Bytes<Void>>

Parameters:

i - integer to prepend to.

prewriteLong
```
@NotNull
public @NotNull Bytes<Void> prewriteLong(long l)
```
Description copied from interface: BytesPrepender

Write backward in binary an 8 byte long
Note: it moves the readPosition not the writePosition / readLimit

Specified by:

prewriteLong in interface BytesPrepender<Bytes<Void>>

Parameters:

l - long to prepend to.

readByte
```
public byte readByte(long offset)
              throws BufferUnderflowException,
                     IllegalStateException
```
Description copied from interface: RandomDataInput

Read byte at an offset

Specified by:

readByte in interface RandomDataInput

Parameters:

offset - to read

Returns:

the byte

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

IllegalStateException - if released

peekUnsignedByte
```
public int peekUnsignedByte(long offset)
                     throws IllegalStateException,
                            BufferUnderflowException
```
Description copied from interface: RandomDataInput

Read an unsigned byte at an offset, or -1

Specified by:

peekUnsignedByte in interface RandomDataInput

Parameters:

offset - to read

Returns:

the unsigned byte or -1

Throws:

IllegalStateException - if released

BufferUnderflowException

readShort
```
public short readShort(long offset)
                throws BufferUnderflowException,
                       IllegalStateException
```
Description copied from interface: RandomDataInput

Read a short at an offset

Specified by:

readShort in interface RandomDataInput

Parameters:

offset - to read

Returns:

the short

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

IllegalStateException - if released

readInt
```
public int readInt(long offset)
            throws BufferUnderflowException,
                   IllegalStateException
```
Description copied from interface: RandomDataInput

Read an int at an offset

Specified by:

readInt in interface RandomDataInput

Parameters:

offset - to read

Returns:

the int

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

IllegalStateException - if released

readLong
```
public long readLong(long offset)
              throws BufferUnderflowException,
                     IllegalStateException
```
Description copied from interface: RandomDataInput

Read a long at an offset

Specified by:

readLong in interface RandomDataInput

Parameters:

offset - to read

Returns:

the long

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

IllegalStateException - if released

readFloat
```
public float readFloat(long offset)
                throws BufferUnderflowException,
                       IllegalStateException
```
Description copied from interface: RandomDataInput

Read a float at an offset

Specified by:

readFloat in interface RandomDataInput

Parameters:

offset - to read

Returns:

the float

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

IllegalStateException - if released

readDouble
```
public double readDouble(long offset)
                  throws BufferUnderflowException,
                         IllegalStateException
```
Description copied from interface: RandomDataInput

Read a double at an offset

Specified by:

readDouble in interface RandomDataInput

Parameters:

offset - to read

Returns:

the double

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

IllegalStateException - if released

readVolatileByte
```
public byte readVolatileByte(long offset)
                      throws BufferUnderflowException,
                             IllegalStateException
```
Description copied from interface: RandomDataInput

Read a 8-bit byte from memory with a load barrier.

Specified by:

readVolatileByte in interface RandomDataInput

Parameters:

offset - to read

Returns:

the byte value

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

IllegalStateException - if released

readVolatileShort
```
public short readVolatileShort(long offset)
                        throws BufferUnderflowException,
                               IllegalStateException
```
Description copied from interface: RandomDataInput

Read a 16-bit short from memory with a load barrier.

Specified by:

readVolatileShort in interface RandomDataInput

Parameters:

offset - to read

Returns:

the short value

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

IllegalStateException - if released

readVolatileInt
```
public int readVolatileInt(long offset)
                    throws BufferUnderflowException,
                           IllegalStateException
```
Description copied from interface: RandomDataInput

Read a 32-bit int from memory with a load barrier.

Specified by:

readVolatileInt in interface RandomDataInput

Parameters:

offset - to read

Returns:

the int value

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

IllegalStateException - if released

readVolatileLong
```
public long readVolatileLong(long offset)
                      throws BufferUnderflowException,
                             IllegalStateException
```
Description copied from interface: RandomDataInput

Read a 64-bit long from memory with a load barrier.

Specified by:

readVolatileLong in interface RandomDataInput

Parameters:

offset - to read

Returns:

the long value

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

IllegalStateException - if released

nativeRead
```
public void nativeRead(long position,
                       long address,
                       long size)
                throws BufferUnderflowException,
                       IllegalStateException
```
Description copied from interface: RandomDataInput

expert level method for copying data to native memory.

Specified by:

nativeRead in interface RandomDataInput

Parameters:

position - within the ByteStore to copy.

address - in native memory

size - in bytes

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

IllegalStateException - if released

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

writeMarshallableLength16
```
public void writeMarshallableLength16(@NotNull
                                      @NotNull WriteBytesMarshallable marshallable)
                               throws IllegalArgumentException,
                                      BufferOverflowException,
                                      BufferUnderflowException,
                                      IllegalStateException
```
Description copied from interface: Bytes

Writes the content of the provided marshallable to this Bytes object converting from an object to a number of bytes.
The content of this Bytes object will have a 16-bit length indicator preceding the actual object.

Specified by:

writeMarshallableLength16 in interface Bytes<Void>

Specified by:

writeMarshallableLength16 in interface BytesOut<Void>

Parameters:

marshallable - non-null object to write to this Bytes object

Throws:

BufferOverflowException - if the capacity of this Bytes object is insufficient.

IllegalStateException - if this Bytes object or the provided bytesOut has been previously released or if the contents of this Bytes object cannot fit under 16-bit addressing

IllegalArgumentException

BufferUnderflowException

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` to the contents of this Bytes object.

Specified by:

write in interface Bytes<Void>

Parameters:

inputStream - non-null to read from

Returns:

this Bytes object

Throws:

IOException - if an I/O error occur on the inputStream

IllegalStateException - if this Bytes object or the provided bytesOut has been previously released

BufferOverflowException - if this Bytes object lacks capacity to write the entire provided inputStream

writeStopBit

@NotNull
public @NotNull Bytes<Void> writeStopBit(long x)
                                           throws BufferOverflowException,
                                                  IllegalStateException

Description copied from interface: StreamingDataOutput

Write a stop bit encoded long

Specified by:: writeStopBit in interface StreamingDataOutput<Bytes<Void>>
Parameters:: x - long to write
Returns:: this.
Throws:: BufferOverflowException; IllegalStateException

writeStopBit

@NotNull
public @NotNull Bytes<Void> writeStopBit(char x)
                                           throws BufferOverflowException,
                                                  IllegalStateException

Specified by:: writeStopBit in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalStateException

writeStopBit

@NotNull
public @NotNull Bytes<Void> writeStopBit(double d)
                                           throws BufferOverflowException,
                                                  IllegalStateException

Specified by:: writeStopBit in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalStateException

writeStopBitDecimal

@NotNull
public @NotNull Bytes<Void> writeStopBitDecimal(double d)
                                                  throws BufferOverflowException,
                                                         IllegalStateException

Specified by:: writeStopBitDecimal in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalStateException

writeUtf8
```
@NotNull
public @NotNull Bytes<Void> writeUtf8(@Nullable
                                               @Nullable CharSequence text)
                                        throws BufferOverflowException,
                                               IllegalStateException,
                                               IllegalArgumentException
```
Description copied from interface: StreamingDataOutput

Write the same encoding as writeUTF with the following changes. 1) The length is stop bit encoded i.e. one byte longer for short strings, but is not limited in length. 2) The string can be null.

Specified by:

writeUtf8 in interface StreamingDataOutput<Bytes<Void>>

Parameters:

text - the string value to be written. Can be null.

Throws:

BufferOverflowException - if there is not enough space left

IllegalStateException

IllegalArgumentException

writeUtf8

@NotNull
public @NotNull Bytes<Void> writeUtf8(@Nullable
                                               @Nullable String text)
                                        throws BufferOverflowException,
                                               IllegalStateException

Specified by:: writeUtf8 in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalStateException

write8bit

@NotNull
public @NotNull Bytes<Void> write8bit(@Nullable
                                               @Nullable CharSequence text)
                                        throws BufferOverflowException,
                                               IllegalStateException,
                                               BufferUnderflowException,
                                               ArithmeticException

Specified by:: write8bit in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalStateException; BufferUnderflowException; ArithmeticException

write8bit

@NotNull
public @NotNull Bytes<Void> write8bit(@NotNull
                                               @NotNull CharSequence text,
                                               int start,
                                               int length)
                                        throws BufferOverflowException,
                                               IndexOutOfBoundsException,
                                               IllegalStateException,
                                               BufferUnderflowException,
                                               ArithmeticException

Specified by:: write8bit in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; 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

Specified by:: write8bit in interface StreamingDataOutput<Bytes<Void>>
Throws:: 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.

IllegalStateException - if this StreamingDataOutput has been previously released.

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.; IllegalStateException - if this StreamingDataOutput has been previously released.; IndexOutOfBoundsException

write8bit

@NotNull
public @NotNull Bytes<Void> write8bit(@Nullable
                                               @Nullable String s)
                                        throws BufferOverflowException,
                                               IllegalStateException,
                                               ArithmeticException

Specified by:: write8bit in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalStateException; ArithmeticException

write8bit

@NotNull
public @NotNull Bytes<Void> write8bit(@Nullable
                                               @Nullable BytesStore bs)
                                        throws BufferOverflowException,
                                               IllegalStateException,
                                               BufferUnderflowException

Throws:: BufferOverflowException; IllegalStateException; BufferUnderflowException

writeUnsignedByte

@NotNull
public @NotNull Bytes<Void> writeUnsignedByte(int i)
                                                throws BufferOverflowException,
                                                       IllegalStateException,
                                                       ArithmeticException

Specified by:: writeUnsignedByte in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalStateException; ArithmeticException

writeUnsignedShort

@NotNull
public @NotNull Bytes<Void> writeUnsignedShort(int u16)
                                                 throws BufferOverflowException,
                                                        IllegalStateException,
                                                        ArithmeticException

Specified by:: writeUnsignedShort in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalStateException; ArithmeticException

writeInt24

@NotNull
public @NotNull Bytes<Void> writeInt24(int i)
                                         throws BufferOverflowException,
                                                IllegalStateException,
                                                ArithmeticException

Specified by:: writeInt24 in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalStateException; ArithmeticException

writeUnsignedInt24

@NotNull
public @NotNull Bytes<Void> writeUnsignedInt24(int i)
                                                 throws BufferOverflowException,
                                                        IllegalStateException,
                                                        ArithmeticException

Specified by:: writeUnsignedInt24 in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalStateException; ArithmeticException

writeUnsignedInt

@NotNull
public @NotNull Bytes<Void> writeUnsignedInt(long i)
                                               throws BufferOverflowException,
                                                      ArithmeticException,
                                                      IllegalStateException

Specified by:: writeUnsignedInt in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; ArithmeticException; IllegalStateException

write

@NotNull
public @NotNull Bytes<Void> write(@NotNull
                                           @NotNull RandomDataInput bytes)
                                    throws IllegalStateException,
                                           BufferOverflowException

Description copied from interface: StreamingDataOutput

Write all data or fail.

Calling this method will update the cursors of this, but not the bytes we read from.

Specified by:: write in interface StreamingDataOutput<Bytes<Void>>
Throws:: IllegalStateException; BufferOverflowException

write
```
public Bytes<Void> write(@NotNull
                         @NotNull BytesStore<?,?> bytes)
                  throws IllegalStateException,
                         BufferOverflowException
```
Description copied from interface: StreamingDataOutput

Writes all the passed BytesStore or it fails. If you want to read only as much as there is use read
Calling this method will update the cursors of this, but not the bytes we read from.

Specified by:

write in interface StreamingDataOutput<Bytes<Void>>

Parameters:

bytes - to write

Returns:

this

Throws:

IllegalStateException

BufferOverflowException

See Also:

StreamingDataInput.read(Bytes)

writeSome
```
@NotNull
public @NotNull Bytes<Void> writeSome(@NotNull
                                               @NotNull Bytes<?> bytes)
                                        throws IllegalStateException
```
Description copied from interface: StreamingDataOutput

Write all data available from bytes argument, constrained by how much space available in this.
Calling this method will update the cursors of this, but not the bytes we read from.

Specified by:

writeSome in interface StreamingDataOutput<Bytes<Void>>

Throws:

IllegalStateException

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

Write all data or fail.

Calling this method will update the cursors of this, but not the bytes we read from.

Specified by:: write in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; BufferUnderflowException; IllegalStateException; IllegalArgumentException

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

Write all data or fail.

Calling this method will update the cursors of this, but not the bytes we read from.

Specified by:: write in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; BufferUnderflowException; IllegalStateException; IllegalArgumentException

write
```
@NotNull
public @NotNull Bytes<Void> write(byte[] byteArray)
                                    throws BufferOverflowException,
                                           IllegalStateException
```
Description copied from interface: StreamingDataOutput

Write all data or fail.
Calling this method will update the cursors of this.

Specified by:

write in interface StreamingDataOutput<Bytes<Void>>

Parameters:

byteArray - to write

Throws:

BufferOverflowException

IllegalStateException

writeBoolean

@NotNull
public @NotNull Bytes<Void> writeBoolean(boolean flag)
                                           throws BufferOverflowException,
                                                  IllegalStateException

Specified by:: writeBoolean in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalStateException

writeEnum

public <E extends Enum<E>> Bytes<Void> writeEnum(@NotNull
                                                 E e)
                                          throws BufferOverflowException,
                                                 IllegalStateException,
                                                 ArithmeticException

Specified by:: writeEnum in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalStateException; ArithmeticException

writePositionRemaining

public void writePositionRemaining(long position,
                                   long length)
                            throws BufferOverflowException

Specified by:: writePositionRemaining in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException

writeHistogram

public void writeHistogram(@NotNull
                           @NotNull net.openhft.chronicle.core.util.Histogram histogram)
                    throws IllegalStateException,
                           BufferOverflowException

Specified by:: writeHistogram in interface StreamingDataOutput<Bytes<Void>>
Throws:: IllegalStateException; BufferOverflowException

writeBigDecimal

public void writeBigDecimal(@NotNull
                            @NotNull BigDecimal bd)
                     throws IllegalArgumentException,
                            IllegalStateException,
                            BufferOverflowException

Specified by:: writeBigDecimal in interface StreamingDataOutput<Bytes<Void>>
Throws:: IllegalArgumentException; IllegalStateException; BufferOverflowException

writeBigInteger

public void writeBigInteger(@NotNull
                            @NotNull BigInteger bi)
                     throws IllegalArgumentException,
                            IllegalStateException,
                            BufferOverflowException

Specified by:: writeBigInteger in interface StreamingDataOutput<Bytes<Void>>
Throws:: IllegalArgumentException; IllegalStateException; BufferOverflowException

writeWithLength

public void writeWithLength(@NotNull
                            @NotNull RandomDataInput bytes)
                     throws IllegalStateException,
                            BufferOverflowException

Specified by:: writeWithLength in interface StreamingDataOutput<Bytes<Void>>
Throws:: IllegalStateException; BufferOverflowException

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.RandomDataInput

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

retainsComments

comment

indent

copy

isElastic

ensureCapacity

bytesStore

compact

clear

isDirectMemory

capacity

addressForRead

addressForWrite

addressForWritePosition

compareAndSwapInt

testAndSetInt

compareAndSwapLong

underlyingObject

move

reserve

release

releaseLast

refCount

tryReserve

reservedBy

writeByte

writeShort

writeInt24

writeInt

writeOrderedInt

writeLong

writeOrderedLong

writeFloat

writeDouble

writeVolatileByte

writeVolatileShort

writeVolatileInt

writeVolatileLong

write

write

write