HexDumpBytes (OpenHFT/Chronicle-Bytes 2.21ea11 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>>, RandomDataInput, RandomDataOutput<Bytes<Void>>, StreamingCommon<Bytes<Void>>, StreamingDataOutput<Bytes<Void>>, net.openhft.chronicle.core.io.ReferenceCounted, net.openhft.chronicle.core.io.ReferenceOwner
```
public class HexDumpBytes
extends Object
implements Bytes<Void>
```

Field Summary
- Fields inherited from interface net.openhft.chronicle.bytes.Bytes
  DEFAULT_BYTE_BUFFER_CAPACITY, MAX_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.ReferenceOwner
  INIT

Constructor Summary

Constructors
Constructor and Description

HexDumpBytes()

Constructors
Constructor and Description
`HexDumpBytes()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`long`	`addressForRead(long offset)` Obtain the underlying addressForRead.
`default long`	`addressForRead(long offset, int buffer)`
`long`	`addressForWrite(long offset)` Obtain the underlying addressForRead.
`long`	`addressForWritePosition()`
`default ByteOrder`	`byteOrder()`
`@NotNull BytesStore`	`bytesStore()`
`long`	`capacity()`
`@NotNull Bytes`	`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(CharSequence comment)` Add comment as approriate for the toHexString format
`@NotNull Bytes`	`compact()` Compact these Bytes by moving the readPosition to the start.
`default boolean`	`compareAndSwapDouble(long offset, double expected, double value)` Perform a 64-bit double CAS at a given offset.
`default boolean`	`compareAndSwapFloat(long offset, float expected, float value)` Perform a 32-bit float CAS at a given offset.
`boolean`	`compareAndSwapInt(long offset, int expected, int value)` Perform a 32-bit CAS at a given offset.
`boolean`	`compareAndSwapLong(long offset, long expected, long value)` Perform a 64-bit CAS at a given offset.
`BytesStore`	`copy()`
`void`	`ensureCapacity(long size)` grow the buffer if the buffer is elastic, if the buffer is not elastic and there is not enough capacity then this method will throws `BufferOverflowException`
`boolean`	`equals(Object obj)`
`static HexDumpBytes`	`fromText(CharSequence text)`
`static HexDumpBytes`	`fromText(Reader reader)`
`int`	`hashCode()`
`BytesOut`	`indent(int n)` Adjust the indent for nested data
`boolean`	`isDirectMemory()`
`boolean`	`isElastic()` Returns if this Bytes is elastic.
`int`	`lastDecimalPlaces()`
`void`	`lastDecimalPlaces(int lastDecimalPlaces)` Store the last number of decimal places.
`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)`
`default void`	`parse8bit(Appendable buffer, @NotNull StopCharsTester stopCharsTester)` parse text with ISO-8859-1 decoding as character terminated.
`default void`	`parse8bit(Appendable buffer, @NotNull StopCharTester stopCharTester)` parse text with ISO-8859-1 decoding as character terminated.
`default void`	`parse8bit(Bytes buffer, @NotNull StopCharsTester stopCharsTester)`
`default String`	`parse8bit(@NotNull StopCharTester stopCharTester)` parse text with ISO-8859-1 decoding as character terminated.
`default void`	`parse8bit(StringBuilder buffer, @NotNull StopCharsTester stopCharsTester)`
`default @NotNull BigDecimal`	`parseBigDecimal()`
`default @Nullable Boolean`	`parseBoolean()`
`default @Nullable Boolean`	`parseBoolean(@NotNull StopCharTester tester)` Return true or false, or null if it could not be detected as true or false.
`default double`	`parseDouble()` parse text as a double decimal.
`default float`	`parseFloat()` parse text as a float decimal.
`default int`	`parseInt()` parse text as an int.
`default long`	`parseLong()` parse text as a long integer.
`default long`	`parseLongDecimal()` Parse the significant digits of a decimal number.
`default void`	`parseUTF(@NotNull Appendable buffer, @NotNull StopCharsTester stopCharsTester)` Deprecated.
`default void`	`parseUTF(@NotNull Appendable buffer, @NotNull StopCharTester stopCharTester)` Deprecated.
`default @NotNull String`	`parseUTF(@NotNull StopCharTester stopCharTester)` Deprecated.
`default void`	`parseUtf8(@NotNull Appendable buffer, @NotNull StopCharsTester stopCharsTester)` parse text with UTF-8 decoding as one or two character terminated.
`default void`	`parseUtf8(@NotNull Appendable buffer, @NotNull StopCharTester stopCharTester)` parse text with UTF-8 decoding as character terminated.
`default @NotNull String`	`parseUtf8(@NotNull StopCharTester stopCharTester)` parse text with UTF-8 decoding as character terminated.
`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(@NotNull byte[] bytes)`
`int`	`read(@NotNull byte[] bytes, int off, int len)`
`void`	`read(@NotNull ByteBuffer buffer)`
`void`	`read(@NotNull Bytes bytes, int length)`
`int`	`read(@NotNull char[] bytes, int off, int len)`
`@Nullable String`	`read8bit()`
`<ACS extends Appendable & CharSequence> boolean`	`read8bit(ACS sb)`
`boolean`	`read8bit(@NotNull Bytes b)`
`boolean`	`read8bit(@NotNull StringBuilder sb)`
`@NotNull BigDecimal`	`readBigDecimal()`
`@NotNull BigInteger`	`readBigInteger()`
`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)`
`default @NotNull Reader`	`reader()` Access these bytes as an ISO-8859-1 encoded Reader
`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()`
`@NotNull Bytes<Void>`	`readLimit(long limit)`
`long`	`readLong()`
`long`	`readLong(long offset)` Read a long at an offset
`<T extends ReadBytesMarshallable> T`	`readMarshallableLength16(Class<T> tClass, T object)`
`long`	`readPosition()` The read position must be start() <= readPosition() && readPosition() <= readLimit() && readPosition < safeLimit()
`@NotNull Bytes<Void>`	`readPosition(long position)`
`@NotNull Bytes<Void>`	`readPositionRemaining(long position, long remaining)`
`@NotNull Bytes<Void>`	`readPositionUnlimited(long position)`
`long`	`readRemaining()`
`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.
`<ACS extends Appendable & CharSequence> boolean`	`readUtf8(ACS sb)` The same as readUtf8() except the chars are copied to a truncated StringBuilder.
`<ACS extends Appendable & CharSequence> long`	`readUtf8(long offset, ACS sb)` Truncates `sb` (it must be a `StringBuilder` or `Bytes`) and reads a char sequence from the given `offset`, encoded as Utf8, into it.
`<ACS extends Appendable & CharSequence> long`	`readUtf8Limited(long offset, ACS 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.
`@Nullable String`	`readUTFΔ()`
`<ACS extends Appendable & CharSequence> boolean`	`readUTFΔ(ACS 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(Bytes bytes)`
`void`	`readWithLength(long length, @NotNull BytesOut<Void> bytesOut)`
`void`	`readWithLength(long length, @NotNull net.openhft.chronicle.core.util.ThrowingConsumer<Bytes<Void>,net.openhft.chronicle.core.io.IORuntimeException> bytesConsumer)` Perform a set of actions 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.
`long`	`realWriteRemaining()`
`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
`default boolean`	`skipTo(@NotNull StopCharTester tester)` Skip text until a terminating character is reached.
`default long`	`start()`
`void`	`testAndSetInt(long offset, int expected, int value)`
`@NotNull String`	`toHexString()`
`@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(@NotNull byte[] bytes)`
`@NotNull Bytes<Void>`	`write(byte[] bytes, int offset, int length)` Write all data or fail.
`Bytes<Void>`	`write(@NotNull BytesStore bytes)` Writes all the 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(CharSequence cs)`
`@NotNull Bytes<Void>`	`write(@NotNull CharSequence s, int start, int length)`
`Bytes`	`write(InputStream inputStream)`
`@NotNull Bytes<Void>`	`write(long offsetInRDO, byte[] bytes, int offset, int length)`
`void`	`write(long offsetInRDO, ByteBuffer bytes, int offset, int length)`
`@NotNull Bytes<Void>`	`write(long writeOffset, RandomDataInput bytes, long readOffset, long length)`
`@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 cs)`
`@NotNull Bytes<Void>`	`write8bit(@NotNull CharSequence s, int start, int length)`
`@NotNull Bytes<Void>`	`write8bit(@Nullable String s)`
`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()`
`@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(WriteBytesMarshallable marshallable)`
`@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()`
`@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(ByteBuffer buffer)`
`@NotNull Bytes<Void>`	`writeSome(@NotNull Bytes bytes)`
`@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(CharSequence cs)` Write the same encoding as `writeUTF` with the following changes.
`@NotNull Bytes<Void>`	`writeUtf8(String s)`
`@NotNull Bytes<Void>`	`writeUTFΔ(CharSequence cs)`
`@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(RandomDataInput bytes)`

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

Methods inherited from interface net.openhft.chronicle.bytes.BytesStore
addAndGetDoubleNotAtomic, addAndGetFloatNotAtomic, addAndGetIntNotAtomic, addAndGetShortNotAtomic, addAndGetUnsignedByteNotAtomic, byteCheckSum, byteCheckSum, bytesForWrite, charAt, cipher, cipher, contentEquals, empty, endsWith, equalBytes, from, inside, inside, isEmpty, length, nativePointer, startsWith, startsWith, subSequence, to8bitString, toDebugString, toDebugString, wrap, wrap, wrap, writeMaxInt, writeMaxLong, zeroOut

Methods inherited from interface net.openhft.chronicle.bytes.RandomDataOutput
append, append, write, write, writeBoolean, writeByte, 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
addAndGetDouble, addAndGetFloat, addAndGetInt, addAndGetLong, 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.StreamingDataInput
inputStream, parseHexLong, parseUTF, parseUtf8, parseUtf8, rawReadByte, rawReadInt, rawReadLong, read, readChar, readIncompleteLong, readLimitToCapacity, readUtf8, readUtf8, 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
alignBy, appendUtf8, appendUtf8, appendUtf8, appendUtf8, appendUtf8, appendUtf8, canWriteDirect, copyFrom, outputStream, rawWriteByte, rawWriteInt, rawWriteLong, unsafeWriteObject, unsafeWriteObject, writeChar

Methods inherited from interface net.openhft.chronicle.core.io.ReferenceCounted
releaseLast, reserveTransfer

Methods inherited from interface net.openhft.chronicle.core.io.ReferenceOwner
referenceId, referenceName, temporary

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

Constructor Detail
- HexDumpBytes
```
public HexDumpBytes()
```

Method Detail

fromText

public static HexDumpBytes fromText(Reader reader)
                             throws NumberFormatException

Throws:: NumberFormatException

fromText

public static HexDumpBytes fromText(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:

How many more bytes can we read.

writeRemaining
```
public long writeRemaining()
```
Returns:

How many more bytes can we written.

readLimit
```
public long readLimit()
```
Returns:

the highest offset or position allowed for this buffer.

writeLimit
```
public long writeLimit()
```

toHexString
```
@NotNull
public @NotNull String toHexString()
```
Specified by:

toHexString in interface Bytes<Void>

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

Specified by:

retainsComments in interface BytesComment<BytesOut<Void>>

Returns:

true if comments are kept

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

Add comment as approriate 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 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()
```
Specified by:

copy in interface Bytes<Void>

Specified by:

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

Returns:

a copy of this Bytes from position() to limit().

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

Returns if this Bytes 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 is elastic

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

grow the buffer if the buffer is elastic, if the buffer is not elastic and there is not enough capacity then this method will throws BufferOverflowException

Specified by:

ensureCapacity in interface Bytes<Void>

Parameters:

size - the capacity that you required

Throws:

IllegalArgumentException - if the buffer is not elastic and there is not enough space

IllegalStateException

bytesStore
```
@NotNull
public @NotNull BytesStore bytesStore()
```
Specified by:

bytesStore in interface Bytes<Void>

Specified by:

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

Returns:

the ByteStore this Bytes wraps.

compact
```
@NotNull
public @NotNull Bytes 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

clear
```
@NotNull
public @NotNull Bytes 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

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

Perform a 32-bit CAS at a given offset.

Parameters:: offset - to perform CAS; expected - value; value - to set
Returns:: true, if successful.
Throws:: BufferOverflowException; IllegalStateException

testAndSetInt

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

Throws:: IllegalStateException; BufferOverflowException

compareAndSwapLong

public boolean compareAndSwapLong(long offset,
                                  long expected,
                                  long value)
                           throws BufferOverflowException,
                                  IllegalStateException

Perform a 64-bit CAS at a given offset.

Parameters:: offset - to perform CAS; expected - value; value - to set
Returns:: true, if successful.
Throws:: BufferOverflowException; 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[] bytes,
                                           int offset,
                                           int length)

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

write

public void write(long offsetInRDO,
                  ByteBuffer bytes,
                  int offset,
                  int length)

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

write

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

Specified by:: write 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

readPosition

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

Throws:: BufferUnderflowException; IllegalStateException

readLimit

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

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.

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.

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.

readStopBit

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

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

readStopBitChar

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

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

readStopBitDouble

public double readStopBitDouble()
                         throws IllegalStateException

Throws:: IllegalStateException

readStopBitDecimal

public double readStopBitDecimal()
                          throws IllegalStateException,
                                 BufferUnderflowException

Throws:: IllegalStateException; BufferUnderflowException

readByte

public byte readByte()
              throws IllegalStateException

Throws:: IllegalStateException

readUnsignedByte
```
public int readUnsignedByte()
                     throws IllegalStateException
```
Returns:

the next unsigned 8 bit value or -1;

Throws:

IllegalStateException

uncheckedReadUnsignedByte
```
public int uncheckedReadUnsignedByte()
```
Returns:

the next unsigned 8 bit value or -1;

readShort

public short readShort()
                throws BufferUnderflowException,
                       IllegalStateException

Throws:: BufferUnderflowException; IllegalStateException

readInt

public int readInt()
            throws BufferUnderflowException,
                   IllegalStateException

Throws:: BufferUnderflowException; IllegalStateException

readLong

public long readLong()
              throws BufferUnderflowException,
                     IllegalStateException

Throws:: BufferUnderflowException; IllegalStateException

readFloat

public float readFloat()
                throws BufferUnderflowException,
                       IllegalStateException

Throws:: BufferUnderflowException; IllegalStateException

readDouble

public double readDouble()
                  throws BufferUnderflowException,
                         IllegalStateException

Throws:: BufferUnderflowException; IllegalStateException

readVolatileInt

public int readVolatileInt()
                    throws BufferUnderflowException,
                           IllegalStateException

Throws:: BufferUnderflowException; IllegalStateException

readVolatileLong

public long readVolatileLong()
                      throws BufferUnderflowException,
                             IllegalStateException

Throws:: BufferUnderflowException; IllegalStateException

peekUnsignedByte

public int peekUnsignedByte()
                     throws IllegalStateException

Throws:: IllegalStateException

lastDecimalPlaces
```
public int lastDecimalPlaces()
```
Returns:

the last number of decimal places for parseDouble or parseLongDecimal

lastDecimalPlaces
```
public void lastDecimalPlaces(int lastDecimalPlaces)
```
Store the last number of decimal places. If

Parameters:

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

readBigDecimal

@NotNull
public @NotNull BigDecimal readBigDecimal()
                                            throws BufferUnderflowException,
                                                   ArithmeticException,
                                                   IllegalStateException

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

readBigInteger

@NotNull
public @NotNull BigInteger readBigInteger()
                                            throws BufferUnderflowException,
                                                   ArithmeticException,
                                                   IllegalStateException

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

readWithLength

public void readWithLength(long length,
                           @NotNull
                           @NotNull BytesOut<Void> bytesOut)
                    throws BufferUnderflowException,
                           net.openhft.chronicle.core.io.IORuntimeException,
                           IllegalStateException,
                           BufferOverflowException

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

readMarshallableLength16

public <T extends ReadBytesMarshallable> T readMarshallableLength16(Class<T> tClass,
                                                                    T object)
                                                             throws BufferUnderflowException,
                                                                    IllegalStateException

Specified by:: readMarshallableLength16 in interface Bytes<Void>
Specified by:: readMarshallableLength16 in interface BytesIn<Void>
Throws:: BufferUnderflowException; IllegalStateException

readPositionUnlimited

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

Throws:: BufferUnderflowException; IllegalStateException

readPositionRemaining

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

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.

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.

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

readBoolean

public boolean readBoolean()
                    throws IllegalStateException

Throws:: IllegalStateException

readUnsignedShort

public int readUnsignedShort()
                      throws BufferUnderflowException,
                             IllegalStateException

Throws:: BufferUnderflowException; IllegalStateException

readInt24

public int readInt24()
              throws BufferUnderflowException,
                     IllegalStateException

Throws:: BufferUnderflowException; IllegalStateException

readUnsignedInt24

public int readUnsignedInt24()
                      throws BufferUnderflowException,
                             IllegalStateException

Throws:: BufferUnderflowException; IllegalStateException

readUnsignedInt

public long readUnsignedInt()
                     throws BufferUnderflowException,
                            IllegalStateException

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

Returns:: a Unicode string or null if writeUtf8(null) was called
Throws:: BufferUnderflowException; net.openhft.chronicle.core.io.IORuntimeException; IllegalStateException; ArithmeticException

readUTFΔ

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

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

read8bit

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

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

readUtf8

public <ACS extends Appendable & CharSequence> boolean readUtf8(@NotNull
                                                                ACS 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.

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 <ACS extends Appendable & CharSequence> long readUtf8(long offset,
                                                             @NotNull
                                                             ACS 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:

ACS - buffer type, must be StringBuilder or Bytes

Parameters:

offset - the offset in this RandomDataInput to read char sequence from

sb - the buffer to read char sequence into (truncated first)

Returns:

offset after the normal read char sequence, or -1 - offset, if char sequence is null

Throws:

net.openhft.chronicle.core.io.IORuntimeException

IllegalArgumentException

BufferUnderflowException

ArithmeticException

IllegalStateException

See Also:

RandomDataOutput.writeUtf8(long, CharSequence)

readUtf8Limited
```
public <ACS extends Appendable & CharSequence> long readUtf8Limited(long offset,
                                                                    @NotNull
                                                                    ACS 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:

ACS - buffer type, must be StringBuilder or Bytes

Parameters:

offset - the offset in this RandomDataInput to read char sequence from

sb - the buffer to read char sequence into (truncated first)

maxUtf8Len - the maximum allowed length of the char sequence in Utf8 encoding

Returns:

offset after the normal read char sequence, or -1 - offset, if char sequence is null

Throws:

net.openhft.chronicle.core.io.IORuntimeException

IllegalArgumentException

BufferUnderflowException

IllegalStateException

See Also:

RandomDataOutput.writeUtf8Limited(long, CharSequence, int)

readUtf8Limited
```
@Nullable
public @Nullable String readUtf8Limited(long offset,
                                                  int maxUtf8Len)
                                           throws BufferUnderflowException,
                                                  net.openhft.chronicle.core.io.IORuntimeException,
                                                  IllegalArgumentException,
                                                  IllegalStateException
```
Description copied from interface: RandomDataInput

Reads a char sequence from the given offset, encoded as Utf8. If length of Utf8 encoding of the char sequence exceeds maxUtf8Len, 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:

BufferUnderflowException

net.openhft.chronicle.core.io.IORuntimeException

IllegalArgumentException

IllegalStateException

See Also:

RandomDataOutput.writeUtf8Limited(long, CharSequence, int)

readUTFΔ

public <ACS extends Appendable & CharSequence> boolean readUTFΔ(@NotNull
                                                                ACS 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

Throws:: BufferUnderflowException; IllegalStateException; BufferOverflowException; ArithmeticException

read8bit

public <ACS extends Appendable & CharSequence> boolean read8bit(@NotNull
                                                                ACS 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 StringBuilder sb)
                 throws net.openhft.chronicle.core.io.IORuntimeException,
                        BufferUnderflowException,
                        ArithmeticException,
                        IllegalStateException

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

read

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

Throws:: IllegalStateException; BufferUnderflowException

read

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

Throws:: IllegalStateException; BufferUnderflowException

read

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

Throws:: IllegalStateException

read

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

Throws:: IllegalStateException

read

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

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

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

Throws:: BufferUnderflowException; IllegalStateException; ArithmeticException

readWithLength

public void readWithLength(Bytes bytes)
                    throws ArithmeticException,
                           BufferOverflowException,
                           IllegalStateException,
                           BufferUnderflowException

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.

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.

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

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

realWriteRemaining in interface StreamingDataOutput<Bytes<Void>>

Returns:

writeRemaining with resize

write

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

Description copied from interface: StreamingDataOutput

Write all data or fail.

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

writeSome

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

Parameters:

lenient - if true, return nothing rather than error.

lenient
```
public boolean lenient()
```

writeMarshallableLength16

public void writeMarshallableLength16(WriteBytesMarshallable marshallable)
                               throws IllegalArgumentException,
                                      BufferOverflowException,
                                      BufferUnderflowException,
                                      IllegalStateException

Specified by:: writeMarshallableLength16 in interface Bytes<Void>
Specified by:: writeMarshallableLength16 in interface BytesOut<Void>
Throws:: IllegalArgumentException; BufferOverflowException; BufferUnderflowException; IllegalStateException

write

public Bytes write(InputStream inputStream)
            throws IOException,
                   IllegalStateException,
                   BufferOverflowException

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

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(CharSequence cs)
                                        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:

cs - 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(String s)
                                        throws BufferOverflowException,
                                               IllegalStateException

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

writeUTFΔ

@NotNull
public @NotNull Bytes<Void> writeUTFΔ(CharSequence cs)
                                        throws BufferOverflowException,
                                               IllegalStateException,
                                               IllegalArgumentException,
                                               BufferUnderflowException

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

write8bit

@NotNull
public @NotNull Bytes<Void> write8bit(@Nullable
                                               @Nullable CharSequence cs)
                                        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 s,
                                               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(CharSequence cs)
                                    throws BufferOverflowException,
                                           IllegalStateException,
                                           IndexOutOfBoundsException

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

write

@NotNull
public @NotNull Bytes<Void> write(@NotNull
                                           @NotNull CharSequence s,
                                           int start,
                                           int length)
                                    throws BufferOverflowException,
                                           IndexOutOfBoundsException,
                                           IllegalStateException

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

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

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

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 the passed BytesStore or it fails. If you want to read only as much as there is use read

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

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.

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.

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

write

@NotNull
public @NotNull Bytes<Void> write(@NotNull
                                           @NotNull byte[] bytes)
                                    throws BufferOverflowException,
                                           IllegalStateException

Specified by:: write in interface StreamingDataOutput<Bytes<Void>>
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(RandomDataInput bytes)
                     throws IllegalStateException,
                            BufferOverflowException

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

reader
```
@NotNull
public @NotNull Reader reader()
```
Access these bytes as an ISO-8859-1 encoded Reader

Returns:

as a Reader

parseBoolean

@Nullable
public @Nullable Boolean parseBoolean(@NotNull
                                                @NotNull StopCharTester tester)
                                         throws BufferUnderflowException,
                                                IllegalStateException,
                                                ArithmeticException

Return true or false, or null if it could not be detected as true or false. Case is not important

false: f, false, n, no, 0

true: t, true, y, yes, 1

Parameters:: tester - to detect the end of the text.
Returns:: true, false, or null if neither.
Throws:: BufferUnderflowException; IllegalStateException; ArithmeticException

parseBoolean

@Nullable
public @Nullable Boolean parseBoolean()
                                         throws BufferUnderflowException,
                                                IllegalStateException,
                                                ArithmeticException

Throws:: BufferUnderflowException; IllegalStateException; ArithmeticException

parseUtf8

@NotNull
public @NotNull String parseUtf8(@NotNull
                                          @NotNull StopCharTester stopCharTester)
                                   throws IllegalStateException,
                                          ArithmeticException

parse text with UTF-8 decoding as character terminated.

Parameters:: stopCharTester - to check if the end has been reached.
Returns:: the text as a String.
Throws:: IllegalStateException; ArithmeticException

parseUTF

@NotNull
 @Deprecated
public @NotNull String parseUTF(@NotNull
                                                      @NotNull StopCharTester stopCharTester)
                                               throws IllegalStateException,
                                                      ArithmeticException

Deprecated.

Throws:: IllegalStateException; ArithmeticException

parseUtf8

public void parseUtf8(@NotNull
                      @NotNull Appendable buffer,
                      @NotNull
                      @NotNull StopCharTester stopCharTester)
               throws BufferUnderflowException,
                      IllegalStateException,
                      ArithmeticException

parse text with UTF-8 decoding as character terminated.

Parameters:: buffer - to populate; stopCharTester - to check if the end has been reached.
Throws:: BufferUnderflowException; IllegalStateException; ArithmeticException

parseUTF

@Deprecated
public void parseUTF(@NotNull
                                 @NotNull Appendable buffer,
                                 @NotNull
                                 @NotNull StopCharTester stopCharTester)
                          throws BufferUnderflowException,
                                 IllegalStateException,
                                 ArithmeticException

Deprecated.

Throws:: BufferUnderflowException; IllegalStateException; ArithmeticException

parseUtf8

public void parseUtf8(@NotNull
                      @NotNull Appendable buffer,
                      @NotNull
                      @NotNull StopCharsTester stopCharsTester)
               throws BufferUnderflowException,
                      net.openhft.chronicle.core.io.IORuntimeException,
                      IllegalStateException

parse text with UTF-8 decoding as one or two character terminated.

Parameters:: buffer - to populate; stopCharsTester - to check if the end has been reached.
Throws:: BufferUnderflowException; net.openhft.chronicle.core.io.IORuntimeException; IllegalStateException

parseUTF

@Deprecated
public void parseUTF(@NotNull
                                 @NotNull Appendable buffer,
                                 @NotNull
                                 @NotNull StopCharsTester stopCharsTester)
                          throws BufferUnderflowException,
                                 net.openhft.chronicle.core.io.IORuntimeException,
                                 IllegalStateException

Deprecated.

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

parse8bit

public void parse8bit(Appendable buffer,
                      @NotNull
                      @NotNull StopCharTester stopCharTester)
               throws BufferUnderflowException,
                      BufferOverflowException,
                      IllegalStateException,
                      ArithmeticException

parse text with ISO-8859-1 decoding as character terminated.

Parameters:: buffer - to populate; stopCharTester - to check if the end has been reached.
Throws:: BufferUnderflowException; BufferOverflowException; IllegalStateException; ArithmeticException

parse8bit

public String parse8bit(@NotNull
                        @NotNull StopCharTester stopCharTester)
                 throws BufferUnderflowException,
                        IllegalStateException

parse text with ISO-8859-1 decoding as character terminated.

Parameters:: stopCharTester - to check if the end has been reached.
Throws:: BufferUnderflowException; IllegalStateException

parse8bit

public void parse8bit(Appendable buffer,
                      @NotNull
                      @NotNull StopCharsTester stopCharsTester)
               throws BufferUnderflowException,
                      BufferOverflowException,
                      IllegalStateException,
                      ArithmeticException

parse text with ISO-8859-1 decoding as character terminated.

Parameters:: buffer - to populate; stopCharsTester - to check if the end has been reached.
Throws:: BufferUnderflowException; BufferOverflowException; IllegalStateException; ArithmeticException

parse8bit

public void parse8bit(Bytes buffer,
                      @NotNull
                      @NotNull StopCharsTester stopCharsTester)
               throws BufferUnderflowException,
                      BufferOverflowException,
                      IllegalStateException,
                      ArithmeticException

Throws:: BufferUnderflowException; BufferOverflowException; IllegalStateException; ArithmeticException

parse8bit

public void parse8bit(StringBuilder buffer,
                      @NotNull
                      @NotNull StopCharsTester stopCharsTester)
               throws IllegalStateException

Throws:: IllegalStateException

parseInt

public int parseInt()
             throws BufferUnderflowException,
                    ArithmeticException,
                    IllegalStateException

parse text as an int. The terminating character is consumed.

Returns:: an int.
Throws:: BufferUnderflowException; ArithmeticException; IllegalStateException

parseLong
```
public long parseLong()
               throws BufferUnderflowException,
                      IllegalStateException
```
parse text as a long integer. The terminating character is consumed.

Returns:

a long.

Throws:

BufferUnderflowException

IllegalStateException

parseFloat
```
public float parseFloat()
                 throws BufferUnderflowException,
                        IllegalStateException
```
parse text as a float decimal. The terminating character is consumed.
The number of decimal places can be retrieved with lastDecimalPlaces()

Returns:

a float.

Throws:

BufferUnderflowException

IllegalStateException

parseDouble
```
public double parseDouble()
                   throws BufferUnderflowException,
                          IllegalStateException
```
parse text as a double decimal. The terminating character is consumed.
The number of decimal places can be retrieved with lastDecimalPlaces()

Returns:

a double.

Throws:

BufferUnderflowException

IllegalStateException

parseLongDecimal
```
public long parseLongDecimal()
                      throws BufferUnderflowException,
                             IllegalStateException
```
Parse the significant digits of a decimal number.
The number of decimal places can be retrieved with lastDecimalPlaces()

Returns:

the significant digits

Throws:

BufferUnderflowException

IllegalStateException

skipTo
```
public boolean skipTo(@NotNull
                      @NotNull StopCharTester tester)
               throws IllegalStateException
```
Skip text until a terminating character is reached.

Parameters:

tester - to stop at

Returns:

true if a terminating character was found, false if the end of the buffer was reached.

Throws:

IllegalStateException

parseBigDecimal

@NotNull
public @NotNull BigDecimal parseBigDecimal()
                                             throws IllegalStateException,
                                                    ArithmeticException

Throws:: IllegalStateException; ArithmeticException

start
```
public long start()
```
Returns:

The smallest position allowed in this buffer.

addressForRead

public long addressForRead(long offset,
                           int buffer)
                    throws UnsupportedOperationException,
                           BufferUnderflowException,
                           IllegalStateException

Throws:: UnsupportedOperationException; BufferUnderflowException; IllegalStateException

byteOrder
```
public ByteOrder byteOrder()
```

compareAndSwapFloat

public boolean compareAndSwapFloat(long offset,
                                   float expected,
                                   float value)
                            throws BufferOverflowException,
                                   IllegalStateException

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

Parameters:: offset - to perform CAS; expected - value; value - to set
Returns:: true, if successful.
Throws:: BufferOverflowException; IllegalStateException

compareAndSwapDouble

public boolean compareAndSwapDouble(long offset,
                                    double expected,
                                    double value)
                             throws BufferOverflowException,
                                    IllegalStateException

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

Parameters:: offset - to perform CAS; expected - value; value - to set
Returns:: true, if successful.
Throws:: BufferOverflowException; IllegalStateException

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

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.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.core.io.ReferenceCounted

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

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

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

nativeWrite