HexDumpBytes (OpenHFT/Chronicle-Bytes 2.19.4 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.ReferenceCounted
```
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
- 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

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`
`static HexDumpBytes`	`fromText(CharSequence text)`
`static HexDumpBytes`	`fromText(Reader reader)`
`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 address, long size)` This is an expert level method for copying raw native memory in bulk.
`void`	`nativeRead(long position, long address, long size)` expert level method for copying data to native memory.
`void`	`nativeWrite(long address, long size)` This is an expert level method for writing out 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.
`@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()`
`long`	`refCount()`
`void`	`release()`
`void`	`reserve()`
`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()`
`boolean`	`tryReserve()`
`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)`
`@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)`
`@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()` The read position must be readPosition() <= writePosition() && writePosition() <= writeLimit()
`@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, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface net.openhft.chronicle.bytes.Bytes
allocateDirect, allocateDirect, allocateElasticDirect, allocateElasticDirect, bytesForRead, copyTo, copyTo, elasticByteBuffer, elasticByteBuffer, elasticByteBuffer, elasticHeapByteBuffer, from, from, fromHexString, fromString, indexOf, indexOf, indexOf, indexOf, isClear, isEqual, readWrite, realCapacity, safeLimit, sharedMemory, toHexString, toHexString, toString, toString, toString, unchecked, unchecked, unwrite, wrapForRead, wrapForRead, wrapForWrite, wrapForWrite

Methods inherited from interface net.openhft.chronicle.bytes.BytesStore
addAndGetByteNotAtomic, addAndGetDoubleNotAtomic, addAndGetFloatNotAtomic, addAndGetIntNotAtomic, addAndGetLongNotAtomic, addAndGetShortNotAtomic, addAndGetUnsignedByteNotAtomic, addAndGetUnsignedIntNotAtomic, addAndGetUnsignedShortNotAtomic, byteCheckSum, byteCheckSum, bytesForWrite, charAt, checkRefCount, cipher, cipher, contentEquals, empty, endsWith, equalBytes, inside, inside, isEmpty, isPresent, isPresent, length, longCheckSum, nativePointer, startsWith, startsWith, subSequence, to8bitString, toDebugString, toDebugString, wrap, wrap, wrap, 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, toString

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, readUtf8, readUtf8Limited, readUtf8Limited, readVolatileDouble, readVolatileFloat, subBytes, toByteArray, toTemporaryDirectByteBuffer

Methods inherited from interface net.openhft.chronicle.bytes.StreamingDataInput
inputStream, parseHexLong, parseUTF, parseUtf8, rawReadByte, rawReadInt, readChar, readIncompleteLong

Methods inherited from interface net.openhft.chronicle.bytes.BytesOut
bytesMethodWriter, bytesMethodWriterBuilder, 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, writeChar

Methods inherited from interface net.openhft.chronicle.core.ReferenceCounted
release, releaseAll

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

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

Method Detail

fromText

public static HexDumpBytes fromText(Reader reader)

fromText

public static HexDumpBytes fromText(CharSequence text)

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>

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

indent
```
public BytesOut indent(int n)
```
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.

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

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()
```
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

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

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

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

testAndSetInt

public void testAndSetInt(long offset,
                          int expected,
                          int value)

compareAndSwapLong

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

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

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()
             throws IllegalStateException
```
Specified by:

reserve in interface net.openhft.chronicle.core.ReferenceCounted

Throws:

IllegalStateException

release
```
public void release()
             throws IllegalStateException
```
Specified by:

release in interface net.openhft.chronicle.core.ReferenceCounted

Throws:

IllegalStateException

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

refCount in interface net.openhft.chronicle.core.ReferenceCounted

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

tryReserve in interface net.openhft.chronicle.core.ReferenceCounted

writeByte
```
@NotNull
public @NotNull Bytes<Void> writeByte(long offset,
                                               byte i8)
                                        throws BufferOverflowException
```
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

writeShort
```
@NotNull
public @NotNull Bytes<Void> writeShort(long offset,
                                                short i)
                                         throws BufferOverflowException
```
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

writeInt24

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

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

writeInt
```
@NotNull
public @NotNull Bytes<Void> writeInt(long offset,
                                              int i)
                                       throws BufferOverflowException
```
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

writeOrderedInt
```
@NotNull
public @NotNull Bytes<Void> writeOrderedInt(long offset,
                                                     int i)
                                              throws BufferOverflowException
```
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

writeLong
```
@NotNull
public @NotNull Bytes<Void> writeLong(long offset,
                                               long i)
                                        throws BufferOverflowException
```
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

writeOrderedLong
```
@NotNull
public @NotNull Bytes<Void> writeOrderedLong(long offset,
                                                      long i)
                                               throws BufferOverflowException
```
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

writeFloat
```
@NotNull
public @NotNull Bytes<Void> writeFloat(long offset,
                                                float d)
                                         throws BufferOverflowException
```
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

writeDouble
```
@NotNull
public @NotNull Bytes<Void> writeDouble(long offset,
                                                 double d)
                                          throws BufferOverflowException
```
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

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)
                                    throws BufferOverflowException,
                                           IllegalArgumentException

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

write

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

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

write

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

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

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

Throws:: BufferUnderflowException

readLimit

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

Throws:: BufferUnderflowException

readSkip
```
@NotNull
public @NotNull Bytes<Void> readSkip(long bytesToSkip)
                                       throws BufferUnderflowException
```
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

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

Throws:: net.openhft.chronicle.core.io.IORuntimeException

readStopBitChar

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

Throws:: net.openhft.chronicle.core.io.IORuntimeException

readStopBitDouble
```
public double readStopBitDouble()
```

readStopBitDecimal

public double readStopBitDecimal()
                          throws BufferOverflowException

Throws:: BufferOverflowException

readByte
```
public byte readByte()
```

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

the next unsigned 8 bit value or -1;

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

the next unsigned 8 bit value or -1;

readShort

public short readShort()
                throws BufferUnderflowException

Throws:: BufferUnderflowException

readInt

public int readInt()
            throws BufferUnderflowException

Throws:: BufferUnderflowException

readLong

public long readLong()
              throws BufferUnderflowException

Throws:: BufferUnderflowException

readFloat

public float readFloat()
                throws BufferUnderflowException

Throws:: BufferUnderflowException

readDouble

public double readDouble()
                  throws BufferUnderflowException

Throws:: BufferUnderflowException

readVolatileInt

public int readVolatileInt()
                    throws BufferUnderflowException

Throws:: BufferUnderflowException

readVolatileLong

public long readVolatileLong()
                      throws BufferUnderflowException

Throws:: BufferUnderflowException

peekUnsignedByte
```
public int peekUnsignedByte()
```

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

This is an expert level method for copying raw native memory in bulk.

Parameters:

address - of the memory.

size - in bytes.

Throws:

BufferUnderflowException

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()
```
Specified by:

readBigDecimal in interface Bytes<Void>

readBigInteger
```
@NotNull
public @NotNull BigInteger readBigInteger()
```
Specified by:

readBigInteger in interface Bytes<Void>

readWithLength

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

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

readMarshallableLength16

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

Specified by:: readMarshallableLength16 in interface Bytes<Void>
Specified by:: readMarshallableLength16 in interface BytesIn<Void>

readPositionUnlimited

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

Throws:: BufferUnderflowException

readPositionRemaining

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

Throws:: BufferUnderflowException

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

Description copied from interface: StreamingDataInput

Perform a set of actions with a temporary bounds mode.

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

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

Description copied from interface: StreamingDataInput

Perform a set of actions with a temporary bounds mode.

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

readBoolean
```
public boolean readBoolean()
```

readUnsignedShort

public int readUnsignedShort()
                      throws BufferUnderflowException

Throws:: BufferUnderflowException

readInt24

public int readInt24()
              throws BufferUnderflowException

Throws:: BufferUnderflowException

readUnsignedInt24

public int readUnsignedInt24()
                      throws BufferUnderflowException

Throws:: BufferUnderflowException

readUnsignedInt

public long readUnsignedInt()
                     throws BufferUnderflowException

Throws:: BufferUnderflowException

readUtf8
```
@Nullable
public @Nullable String readUtf8()
                                    throws BufferUnderflowException,
                                           net.openhft.chronicle.core.io.IORuntimeException,
                                           IllegalArgumentException
```
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

IllegalArgumentException

readUTFΔ

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

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

read8bit

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

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

readUtf8

public <ACS extends Appendable & CharSequence> boolean readUtf8(@NotNull
                                                                ACS sb)
                                                         throws net.openhft.chronicle.core.io.IORuntimeException,
                                                                IllegalArgumentException,
                                                                BufferUnderflowException

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

readUTFΔ

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

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

read8bit

public boolean read8bit(@NotNull
                        @NotNull Bytes b)
                 throws BufferUnderflowException,
                        IllegalStateException,
                        BufferOverflowException

Throws:: BufferUnderflowException; IllegalStateException; BufferOverflowException

read8bit

public <ACS extends Appendable & CharSequence> boolean read8bit(@NotNull
                                                                ACS sb)
                                                         throws net.openhft.chronicle.core.io.IORuntimeException,
                                                                IllegalArgumentException,
                                                                BufferUnderflowException

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

read8bit

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

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

read

public int read(@NotNull
                @NotNull byte[] bytes)

read

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

read

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

read

public void read(@NotNull
                 @NotNull ByteBuffer buffer)

read

public void read(@NotNull
                 @NotNull Bytes bytes,
                 int length)

readEnum

@NotNull
public <E extends Enum<E>> E readEnum(@NotNull
                                               @NotNull Class<E> eClass)
                                        throws net.openhft.chronicle.core.io.IORuntimeException,
                                               BufferUnderflowException

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

readHistogram

public void readHistogram(@NotNull
                          @NotNull net.openhft.chronicle.core.util.Histogram histogram)

readWithLength

public void readWithLength(Bytes bytes)

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

writeByte

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

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

writePosition
```
public long writePosition()
```
The read position must be readPosition() <= writePosition() && writePosition() <= writeLimit()

Returns:

position to write to.

writeShort

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

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

writeInt

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

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

writeIntAdv

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

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

writeLong

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

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

writeLongAdv

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

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

writeFloat

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

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

writeDouble

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

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

writeDoubleAndInt

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

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

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

Description copied from interface: StreamingDataOutput

Write all data or fail.

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

writeSome

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

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

writeOrderedInt

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

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

writeOrderedLong

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

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

nativeWrite
```
public void nativeWrite(long address,
                        long size)
                 throws BufferOverflowException
```
Description copied from interface: StreamingDataOutput

This is an expert level method for writing out data to native memory.

Specified by:

nativeWrite in interface StreamingDataOutput<Bytes<Void>>

Parameters:

address - to write to.

size - in bytes.

Throws:

BufferOverflowException

clearAndPad
```
@NotNull
public @NotNull Bytes<Void> clearAndPad(long length)
                                          throws BufferOverflowException
```
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()

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

peekUnsignedByte
```
public int peekUnsignedByte(long offset)
```
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

readShort
```
public short readShort(long offset)
                throws BufferUnderflowException
```
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

readInt
```
public int readInt(long offset)
            throws BufferUnderflowException
```
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

readLong
```
public long readLong(long offset)
              throws BufferUnderflowException
```
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

readFloat
```
public float readFloat(long offset)
                throws BufferUnderflowException
```
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

readDouble
```
public double readDouble(long offset)
                  throws BufferUnderflowException
```
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

readVolatileByte
```
public byte readVolatileByte(long offset)
                      throws BufferUnderflowException
```
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

readVolatileShort
```
public short readVolatileShort(long offset)
                        throws BufferUnderflowException
```
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

readVolatileInt
```
public int readVolatileInt(long offset)
                    throws BufferUnderflowException
```
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

readVolatileLong
```
public long readVolatileLong(long offset)
                      throws BufferUnderflowException
```
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

nativeRead
```
public void nativeRead(long position,
                       long address,
                       long size)
                throws BufferUnderflowException
```
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

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)
```
Specified by:

writeMarshallableLength16 in interface Bytes<Void>

Specified by:

writeMarshallableLength16 in interface BytesOut<Void>

write

public Bytes write(InputStream inputStream)
            throws IOException

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

writeStopBit
```
@NotNull
public @NotNull Bytes<Void> writeStopBit(long x)
                                           throws BufferOverflowException
```
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

writeStopBit

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

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

writeStopBit

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

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

writeStopBitDecimal

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

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

writeUtf8
```
@NotNull
public @NotNull Bytes<Void> writeUtf8(CharSequence cs)
                                        throws BufferOverflowException
```
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

writeUtf8

@NotNull
public @NotNull Bytes<Void> writeUtf8(String s)
                                        throws BufferOverflowException

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

writeUTFΔ

@NotNull
public @NotNull Bytes<Void> writeUTFΔ(CharSequence cs)
                                        throws BufferOverflowException

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

write8bit

@NotNull
public @NotNull Bytes<Void> write8bit(@Nullable
                                               @Nullable CharSequence cs)
                                        throws BufferOverflowException

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

write8bit

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

Specified by:: write8bit in interface StreamingDataOutput<Bytes<Void>>
Throws:: BufferOverflowException; IllegalArgumentException; IndexOutOfBoundsException

write

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

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

write

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

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

write8bit

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

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

write8bit

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

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

writeUnsignedByte

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

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

writeUnsignedShort

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

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

writeInt24

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

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

writeUnsignedInt24

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

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

writeUnsignedInt

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

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

write
```
@NotNull
public @NotNull Bytes<Void> write(@NotNull
                                           @NotNull RandomDataInput bytes)
```
Description copied from interface: StreamingDataOutput

Write all data or fail.

Specified by:

write in interface StreamingDataOutput<Bytes<Void>>

write

public Bytes<Void> write(@NotNull
                         @NotNull BytesStore bytes)

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

writeSome

@NotNull
public @NotNull Bytes<Void> writeSome(@NotNull
                                               @NotNull Bytes bytes)

Specified by:: writeSome in interface StreamingDataOutput<Bytes<Void>>

write

@NotNull
public @NotNull Bytes<Void> write(@NotNull
                                           @NotNull RandomDataInput bytes,
                                           long offset,
                                           long length)
                                    throws BufferOverflowException,
                                           BufferUnderflowException

Description copied from interface: StreamingDataOutput

Write all data or fail.

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

write

@NotNull
public @NotNull Bytes<Void> write(@NotNull
                                           @NotNull BytesStore bytes,
                                           long offset,
                                           long length)
                                    throws BufferOverflowException,
                                           BufferUnderflowException

Description copied from interface: StreamingDataOutput

Write all data or fail.

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

write

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

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

writeBoolean

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

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

writeEnum

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

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

writePositionRemaining

public void writePositionRemaining(long position,
                                   long length)

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

writeHistogram

public void writeHistogram(@NotNull
                           @NotNull net.openhft.chronicle.core.util.Histogram histogram)

Specified by:: writeHistogram in interface StreamingDataOutput<Bytes<Void>>

writeBigDecimal

public void writeBigDecimal(@NotNull
                            @NotNull BigDecimal bd)

Specified by:: writeBigDecimal in interface StreamingDataOutput<Bytes<Void>>

writeBigInteger

public void writeBigInteger(@NotNull
                            @NotNull BigInteger bi)

Specified by:: writeBigInteger in interface StreamingDataOutput<Bytes<Void>>

writeWithLength
```
public void writeWithLength(RandomDataInput bytes)
```
Specified by:

writeWithLength in interface StreamingDataOutput<Bytes<Void>>

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)
```
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.

parseBoolean

@Nullable
public @Nullable Boolean parseBoolean()

parseUtf8
```
@NotNull
public @NotNull String parseUtf8(@NotNull
                                          @NotNull StopCharTester stopCharTester)
```
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.

parseUTF

@NotNull
 @Deprecated
public @NotNull String parseUTF(@NotNull
                                                      @NotNull StopCharTester stopCharTester)

Deprecated.

parseUtf8

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

parse text with UTF-8 decoding as character terminated.

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

parseUTF

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

Deprecated.

Throws:: BufferUnderflowException

parseUtf8

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

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

parseUTF

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

Deprecated.

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

parse8bit

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

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

parse8bit
```
public String parse8bit(@NotNull
                        @NotNull StopCharTester stopCharTester)
                 throws BufferUnderflowException
```
parse text with ISO-8859-1 decoding as character terminated.

Parameters:

stopCharTester - to check if the end has been reached.

Throws:

BufferUnderflowException

parse8bit

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

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

parse8bit

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

Throws:: BufferUnderflowException

parse8bit

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

Throws:: BufferUnderflowException

parseInt
```
public int parseInt()
             throws BufferUnderflowException
```
parse text as an int. The terminating character is consumed.

Returns:

an int.

Throws:

BufferUnderflowException

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

Returns:

a long.

Throws:

BufferUnderflowException

parseFloat
```
public float parseFloat()
                 throws BufferUnderflowException
```
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

parseDouble
```
public double parseDouble()
                   throws BufferUnderflowException
```
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

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

Returns:

the significant digits

Throws:

BufferUnderflowException

skipTo
```
public boolean skipTo(@NotNull
                      @NotNull StopCharTester tester)
```
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.

parseBigDecimal

@NotNull
public @NotNull BigDecimal parseBigDecimal()

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

The smallest position allowed in this buffer.

addressForRead

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

Throws:: UnsupportedOperationException; BufferUnderflowException

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

compareAndSwapFloat

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

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

compareAndSwapDouble

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

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

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

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

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

Constructor Detail

HexDumpBytes

Method Detail

fromText

fromText

offsetFormat

numberWrap

numberWrap

readRemaining

writeRemaining

readLimit

writeLimit

toHexString

retainsComments

comment

indent

copy

isElastic

ensureCapacity

bytesStore

compact

clear

isDirectMemory

capacity

addressForRead

addressForWrite

addressForWritePosition

compareAndSwapInt

testAndSetInt

compareAndSwapLong

underlyingObject

move

reserve

release

refCount

tryReserve

writeByte

writeShort

writeInt24

writeInt

writeOrderedInt

writeLong

writeOrderedLong

writeFloat

writeDouble

writeVolatileByte

writeVolatileShort

writeVolatileInt

writeVolatileLong

write

write

write

nativeWrite

readPosition

readLimit

readSkip

uncheckedReadSkipOne

uncheckedReadSkipBackOne

readStopBit

readStopBitChar