HexDumpBytes (OpenHFT/Chronicle-Bytes 2.17.45 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()`
`BytesStore`	`bytesStore()`
`long`	`capacity()`
`Bytes`	`clear()` Set the readPosition= writePosition = start, writeLimit = capacity
`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
`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, StopCharsTester stopCharsTester)` parse text with ISO-8859-1 decoding as character terminated.
`default void`	`parse8bit(Appendable buffer, StopCharTester stopCharTester)` parse text with ISO-8859-1 decoding as character terminated.
`default void`	`parse8bit(Bytes buffer, StopCharsTester stopCharsTester)`
`default String`	`parse8bit(StopCharTester stopCharTester)` parse text with ISO-8859-1 decoding as character terminated.
`default void`	`parse8bit(StringBuilder buffer, StopCharsTester stopCharsTester)`
`default BigDecimal`	`parseBigDecimal()`
`default Boolean`	`parseBoolean()`
`default Boolean`	`parseBoolean(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(Appendable buffer, StopCharsTester stopCharsTester)` Deprecated.
`default void`	`parseUTF(Appendable buffer, StopCharTester stopCharTester)` Deprecated.
`default String`	`parseUTF(StopCharTester stopCharTester)` Deprecated.
`default void`	`parseUtf8(Appendable buffer, StopCharsTester stopCharsTester)` parse text with UTF-8 decoding as one or two character terminated.
`default void`	`parseUtf8(Appendable buffer, StopCharTester stopCharTester)` parse text with UTF-8 decoding as character terminated.
`default String`	`parseUtf8(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
`Bytes<Void>`	`prewrite(byte[] bytes)` Write backward in binary a byte
`Bytes<Void>`	`prewrite(BytesStore bytes)` Write backward in binary a byte
`Bytes<Void>`	`prewriteByte(byte b)` Write backward in binary a byte
`Bytes<Void>`	`prewriteInt(int i)` Write backward in binary a 4 byte int
`Bytes<Void>`	`prewriteLong(long l)` Write backward in binary an 8 byte long
`Bytes<Void>`	`prewriteShort(short i)` Write backward in binary a 2 byte int
`int`	`read(byte[] bytes)`
`int`	`read(byte[] bytes, int off, int len)`
`void`	`read(ByteBuffer buffer)`
`void`	`read(Bytes bytes, int length)`
`int`	`read(char[] bytes, int off, int len)`
`String`	`read8bit()`
`<ACS extends Appendable & CharSequence> boolean`	`read8bit(ACS sb)`
`boolean`	`read8bit(Bytes b)`
`boolean`	`read8bit(StringBuilder sb)`
`BigDecimal`	`readBigDecimal()`
`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(Class<E> eClass)`
`default 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(net.openhft.chronicle.core.util.Histogram histogram)`
`int`	`readInt()`
`int`	`readInt(long offset)` Read an int at an offset
`int`	`readInt24()`
`long`	`readLimit()`
`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()
`Bytes<Void>`	`readPosition(long position)`
`Bytes<Void>`	`readPositionRemaining(long position, long remaining)`
`Bytes<Void>`	`readPositionUnlimited(long position)`
`long`	`readRemaining()`
`short`	`readShort()`
`short`	`readShort(long offset)` Read a short at an offset
`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()`
`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.
`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, BytesOut<Void> bytesOut)`
`void`	`readWithLength(long length, 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, 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(StopCharTester tester)` Skip text until a terminating character is reached.
`default long`	`start()`
`void`	`testAndSetInt(long offset, int expected, int value)`
`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()`
`Void`	`underlyingObject()`
`Bytes<Void>`	`write(byte[] bytes)`
`Bytes<Void>`	`write(byte[] bytes, int offset, int length)` Write all data or fail.
`Bytes<Void>`	`write(BytesStore bytes)`
`Bytes<Void>`	`write(BytesStore bytes, long offset, long length)` Write all data or fail.
`Bytes<Void>`	`write(CharSequence cs)`
`Bytes<Void>`	`write(CharSequence s, int start, int length)`
`Bytes`	`write(InputStream inputStream)`
`Bytes<Void>`	`write(long offsetInRDO, byte[] bytes, int offset, int length)`
`void`	`write(long offsetInRDO, ByteBuffer bytes, int offset, int length)`
`Bytes<Void>`	`write(long writeOffset, RandomDataInput bytes, long readOffset, long length)`
`Bytes<Void>`	`write(RandomDataInput bytes)` Write all data or fail.
`Bytes<Void>`	`write(RandomDataInput bytes, long offset, long length)` Write all data or fail.
`Bytes<Void>`	`write8bit(BytesStore bs)`
`Bytes<Void>`	`write8bit(CharSequence cs)`
`Bytes<Void>`	`write8bit(CharSequence s, int start, int length)`
`Bytes<Void>`	`write8bit(String s)`
`void`	`writeBigDecimal(BigDecimal bd)`
`void`	`writeBigInteger(BigInteger bi)`
`Bytes<Void>`	`writeBoolean(boolean flag)`
`Bytes<Void>`	`writeByte(byte i8)`
`Bytes<Void>`	`writeByte(long offset, byte i8)` Write an unsigned byte at an offset.
`Bytes<Void>`	`writeDouble(double d)`
`Bytes<Void>`	`writeDouble(long offset, double d)` Write a double at an offset.
`Bytes<Void>`	`writeDoubleAndInt(double d, int i)`
`<E extends Enum<E>> Bytes<Void>`	`writeEnum(E e)`
`Bytes<Void>`	`writeFloat(float f)`
`Bytes<Void>`	`writeFloat(long offset, float d)` Write a float at an offset.
`void`	`writeHistogram(net.openhft.chronicle.core.util.Histogram histogram)`
`Bytes<Void>`	`writeInt(int i)`
`Bytes<Void>`	`writeInt(long offset, int i)` Write an int at an offset.
`Bytes<Void>`	`writeInt24(int i)`
`Bytes<Void>`	`writeInt24(long offset, int i)`
`Bytes<Void>`	`writeIntAdv(int i, int advance)`
`long`	`writeLimit()`
`Bytes<Void>`	`writeLimit(long limit)`
`Bytes<Void>`	`writeLong(long i64)`
`Bytes<Void>`	`writeLong(long offset, long i)` Write a long at an offset.
`Bytes<Void>`	`writeLongAdv(long i64, int advance)`
`void`	`writeMarshallableLength16(WriteBytesMarshallable marshallable)`
`Bytes<Void>`	`writeOrderedInt(int i)`
`Bytes<Void>`	`writeOrderedInt(long offset, int i)` Perform a non stalling write with a store barrier.
`Bytes<Void>`	`writeOrderedLong(long i)`
`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()
`Bytes<Void>`	`writePosition(long position)`
`void`	`writePositionRemaining(long position, long length)`
`long`	`writeRemaining()`
`Bytes<Void>`	`writeShort(long offset, short i)` Write a short at an offset.
`Bytes<Void>`	`writeShort(short i16)`
`Bytes<Void>`	`writeSkip(long bytesToSkip)` Skip a number of bytes by moving the writePosition.
`Bytes<Void>`	`writeSome(ByteBuffer buffer)`
`Bytes<Void>`	`writeSome(Bytes bytes)`
`Bytes<Void>`	`writeStopBit(char x)`
`Bytes<Void>`	`writeStopBit(double d)`
`Bytes<Void>`	`writeStopBit(long x)` Write a stop bit encoded long
`Bytes<Void>`	`writeStopBitDecimal(double d)`
`Bytes<Void>`	`writeUnsignedByte(int i)`
`Bytes<Void>`	`writeUnsignedInt(long i)`
`Bytes<Void>`	`writeUnsignedInt24(int i)`
`Bytes<Void>`	`writeUnsignedShort(int u16)`
`Bytes<Void>`	`writeUtf8(CharSequence cs)` Write the same encoding as `writeUTF` with the following changes.
`Bytes<Void>`	`writeUtf8(String s)`
`Bytes<Void>`	`writeUTFΔ(CharSequence cs)`
`Bytes<Void>`	`writeVolatileByte(long offset, byte i8)`
`Bytes<Void>`	`writeVolatileInt(long offset, int i32)`
`Bytes<Void>`	`writeVolatileLong(long offset, long i64)`
`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 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 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 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 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 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 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 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 Bytes<Void> writeInt24(long offset,
                                       int i)
                                throws BufferOverflowException

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

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

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

writeVolatileShort

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

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

writeVolatileInt

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

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

writeVolatileLong

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

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

write

@NotNull
public 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 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 Bytes<Void> readPosition(long position)
                                  throws BufferUnderflowException

Throws:: BufferUnderflowException

readLimit

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

Throws:: BufferUnderflowException

readSkip
```
@NotNull
public 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 BigDecimal readBigDecimal()
```
Specified by:

readBigDecimal in interface Bytes<Void>

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

readBigInteger in interface Bytes<Void>

readWithLength

public void readWithLength(long length,
                           @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 Bytes<Void> readPositionUnlimited(long position)
                                           throws BufferUnderflowException

Throws:: BufferUnderflowException

readPositionRemaining

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

Throws:: BufferUnderflowException

readWithLength0

public 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)
                     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
                           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 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 String readUTFΔ()
                          throws net.openhft.chronicle.core.io.IORuntimeException,
                                 BufferUnderflowException,
                                 IllegalArgumentException

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

read8bit

@Nullable
public 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
                        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
                        StringBuilder sb)
                 throws net.openhft.chronicle.core.io.IORuntimeException,
                        BufferUnderflowException

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

read

public int read(@NotNull
                byte[] bytes)

read

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

read

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

read

public void read(@NotNull
                 ByteBuffer buffer)

read

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

readEnum

@NotNull
public <E extends Enum<E>> E readEnum(@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
                          net.openhft.chronicle.core.util.Histogram histogram)

readWithLength

public void readWithLength(Bytes bytes)

writePosition

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

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

writeLimit

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

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

writeSkip
```
@NotNull
public 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 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 Bytes<Void> writeShort(short i16)
                                throws BufferOverflowException

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

writeInt

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

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

writeIntAdv

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

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

writeLong

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

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

writeLongAdv

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

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

writeFloat

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

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

writeDouble

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

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

writeDoubleAndInt

@NotNull
public 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 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 Bytes<Void> writeSome(ByteBuffer buffer)
                               throws BufferOverflowException

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

writeOrderedInt

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

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

writeOrderedLong

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

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

writeStopBit

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

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

writeStopBitDecimal

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

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

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

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

writeUTFΔ

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

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

write8bit

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

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

write8bit

@NotNull
public Bytes<Void> write8bit(@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 Bytes<Void> write(CharSequence cs)
                           throws BufferOverflowException,
                                  BufferUnderflowException,
                                  IllegalArgumentException

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

write

@NotNull
public Bytes<Void> write(@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 Bytes<Void> write8bit(@Nullable
                                      String s)
                               throws BufferOverflowException

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

write8bit

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

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

writeUnsignedByte

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

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

writeUnsignedShort

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

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

writeInt24

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

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

writeUnsignedInt24

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

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

writeUnsignedInt

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

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

write
```
@NotNull
public Bytes<Void> write(@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
                         BytesStore bytes)

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

writeSome

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

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

write

@NotNull
public Bytes<Void> write(@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 Bytes<Void> write(@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 Bytes<Void> write(@NotNull
                                  byte[] bytes)
                           throws BufferOverflowException

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

writeBoolean

@NotNull
public 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
                           net.openhft.chronicle.core.util.Histogram histogram)

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

writeBigDecimal

public void writeBigDecimal(@NotNull
                            BigDecimal bd)

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

writeBigInteger

public void writeBigInteger(@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 Reader reader()
```
Access these bytes as an ISO-8859-1 encoded Reader

Returns:

as a Reader

parseBoolean
```
@Nullable
public Boolean parseBoolean(@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 Boolean parseBoolean()

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

Deprecated.

parseUtf8

public void parseUtf8(@NotNull
                      Appendable buffer,
                      @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
                                 Appendable buffer,
                                 @NotNull
                                 StopCharTester stopCharTester)
                          throws BufferUnderflowException

Deprecated.

Throws:: BufferUnderflowException

parseUtf8

public void parseUtf8(@NotNull
                      Appendable buffer,
                      @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
                                 Appendable buffer,
                                 @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
                      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
                        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
                      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
                      StopCharsTester stopCharsTester)
               throws BufferUnderflowException

Throws:: BufferUnderflowException

parse8bit

public void parse8bit(StringBuilder buffer,
                      @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
                      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 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