HexDumpBytes (OpenHFT/Chronicle-Bytes 2.17.23 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>>, StreamingDataInput<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.
`long`	`addressForWrite(long offset)` Obtain the underlying addressForRead.
`long`	`addressForWritePosition()`
`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.
`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()`
`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.
`void`	`testAndSetInt(long offset, int expected, int value)`
`String`	`toHexString()` display the hex data of `Bytes` from the position() to the limit()
`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, 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

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

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()
```
    Description copied from interface: Bytes
    
    display the hex data of Bytes from the position() to the limit()
    
    Specified by:
    
    toHexString in interface Bytes<Void>
    
    Returns:
    
    hex representation of the buffer, from example [0D ,OA, FF]
  - 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()
```
    Specified by:
    
    isElastic in interface Bytes<Void>
    
    Returns:
    
    can the Bytes resize when more data is written than it's realCapacity()
  - 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
```
    Specified by:
    
    readPosition in interface StreamingDataInput<Bytes<Void>>
    
    Throws:
    
    BufferUnderflowException
  - readLimit
```
@NotNull
public Bytes<Void> readLimit(long limit)
                               throws BufferUnderflowException
```
    Specified by:
    
    readLimit in interface StreamingDataInput<Bytes<Void>>
    
    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.
    
    Specified by:
    
    readSkip in interface StreamingDataInput<Bytes<Void>>
    
    Parameters:
    
    bytesToSkip - bytes to skip.
    
    Returns:
    
    this
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - uncheckedReadSkipOne
```
public void uncheckedReadSkipOne()
```
    Description copied from interface: StreamingDataInput
    
    Read skip 1 when you are sure this is safe. Use at your own risk when you find a performance problem.
    
    Specified by:
    
    uncheckedReadSkipOne in interface StreamingDataInput<Bytes<Void>>
  - uncheckedReadSkipBackOne
```
public void uncheckedReadSkipBackOne()
```
    Description copied from interface: StreamingDataInput
    
    Read skip -1 when you are sure this is safe. Use at your own risk when you find a performance problem.
    
    Specified by:
    
    uncheckedReadSkipBackOne in interface StreamingDataInput<Bytes<Void>>
  - readStopBit
```
public long readStopBit()
                 throws net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    readStopBit in interface StreamingDataInput<Bytes<Void>>
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException
  - readStopBitChar
```
public char readStopBitChar()
                     throws net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    readStopBitChar in interface StreamingDataInput<Bytes<Void>>
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException
  - readStopBitDouble
```
public double readStopBitDouble()
```
    Specified by:
    
    readStopBitDouble in interface StreamingDataInput<Bytes<Void>>
  - readStopBitDecimal
```
public double readStopBitDecimal()
                          throws BufferOverflowException
```
    Specified by:
    
    readStopBitDecimal in interface StreamingDataInput<Bytes<Void>>
    
    Throws:
    
    BufferOverflowException
  - readByte
```
public byte readByte()
```
    Specified by:
    
    readByte in interface StreamingDataInput<Bytes<Void>>
  - readUnsignedByte
```
public int readUnsignedByte()
```
    Specified by:
    
    readUnsignedByte in interface StreamingDataInput<Bytes<Void>>
    
    Returns:
    
    the next unsigned 8 bit value or -1;
  - uncheckedReadUnsignedByte
```
public int uncheckedReadUnsignedByte()
```
    Specified by:
    
    uncheckedReadUnsignedByte in interface StreamingDataInput<Bytes<Void>>
    
    Returns:
    
    the next unsigned 8 bit value or -1;
  - readShort
```
public short readShort()
                throws BufferUnderflowException
```
    Specified by:
    
    readShort in interface StreamingDataInput<Bytes<Void>>
    
    Throws:
    
    BufferUnderflowException
  - readInt
```
public int readInt()
            throws BufferUnderflowException
```
    Specified by:
    
    readInt in interface StreamingDataInput<Bytes<Void>>
    
    Throws:
    
    BufferUnderflowException
  - readLong
```
public long readLong()
              throws BufferUnderflowException
```
    Specified by:
    
    readLong in interface StreamingDataInput<Bytes<Void>>
    
    Throws:
    
    BufferUnderflowException
  - readFloat
```
public float readFloat()
                throws BufferUnderflowException
```
    Specified by:
    
    readFloat in interface StreamingDataInput<Bytes<Void>>
    
    Throws:
    
    BufferUnderflowException
  - readDouble
```
public double readDouble()
                  throws BufferUnderflowException
```
    Specified by:
    
    readDouble in interface StreamingDataInput<Bytes<Void>>
    
    Throws:
    
    BufferUnderflowException
  - readVolatileInt
```
public int readVolatileInt()
                    throws BufferUnderflowException
```
    Specified by:
    
    readVolatileInt in interface StreamingDataInput<Bytes<Void>>
    
    Throws:
    
    BufferUnderflowException
  - readVolatileLong
```
public long readVolatileLong()
                      throws BufferUnderflowException
```
    Specified by:
    
    readVolatileLong in interface StreamingDataInput<Bytes<Void>>
    
    Throws:
    
    BufferUnderflowException
  - peekUnsignedByte
```
public int peekUnsignedByte()
```
    Specified by:
    
    peekUnsignedByte in interface StreamingDataInput<Bytes<Void>>
  - 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.
    
    Specified by:
    
    nativeRead in interface StreamingDataInput<Bytes<Void>>
    
    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
```
    Specified by:
    
    readPositionUnlimited in interface StreamingDataInput<Bytes<Void>>
    
    Throws:
    
    BufferUnderflowException
  - readPositionRemaining
```
@NotNull
public Bytes<Void> readPositionRemaining(long position,
                                                  long remaining)
                                           throws BufferUnderflowException
```
    Specified by:
    
    readPositionRemaining in interface StreamingDataInput<Bytes<Void>>
    
    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.
    
    Specified by:
    
    readWithLength0 in interface StreamingDataInput<Bytes<Void>>
    
    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.
    
    Specified by:
    
    readWithLength in interface StreamingDataInput<Bytes<Void>>
    
    Throws:
    
    BufferUnderflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - readBoolean
```
public boolean readBoolean()
```
    Specified by:
    
    readBoolean in interface StreamingDataInput<Bytes<Void>>
  - readUnsignedShort
```
public int readUnsignedShort()
                      throws BufferUnderflowException
```
    Specified by:
    
    readUnsignedShort in interface StreamingDataInput<Bytes<Void>>
    
    Throws:
    
    BufferUnderflowException
  - readInt24
```
public int readInt24()
              throws BufferUnderflowException
```
    Specified by:
    
    readInt24 in interface StreamingDataInput<Bytes<Void>>
    
    Throws:
    
    BufferUnderflowException
  - readUnsignedInt24
```
public int readUnsignedInt24()
                      throws BufferUnderflowException
```
    Specified by:
    
    readUnsignedInt24 in interface StreamingDataInput<Bytes<Void>>
    
    Throws:
    
    BufferUnderflowException
  - readUnsignedInt
```
public long readUnsignedInt()
                     throws BufferUnderflowException
```
    Specified by:
    
    readUnsignedInt in interface StreamingDataInput<Bytes<Void>>
    
    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
    
    Specified by:
    
    readUtf8 in interface StreamingDataInput<Bytes<Void>>
    
    Returns:
    
    a Unicode string or null if writeUtf8(null) was called
    
    Throws:
    
    BufferUnderflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
    
    IllegalArgumentException
  - readUTFΔ
```
@Nullable
public String readUTFΔ()
                          throws net.openhft.chronicle.core.io.IORuntimeException,
                                 BufferUnderflowException,
                                 IllegalArgumentException
```
    Specified by:
    
    readUTFΔ in interface StreamingDataInput<Bytes<Void>>
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException
    
    BufferUnderflowException
    
    IllegalArgumentException
  - read8bit
```
@Nullable
public String read8bit()
                          throws net.openhft.chronicle.core.io.IORuntimeException,
                                 BufferUnderflowException
```
    Specified by:
    
    read8bit in interface StreamingDataInput<Bytes<Void>>
    
    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.
    
    Specified by:
    
    readUtf8 in interface StreamingDataInput<Bytes<Void>>
    
    Parameters:
    
    sb - to copy chars to
    
    Returns:
    
    true if there was a String, or false if it was null
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException
    
    IllegalArgumentException
    
    BufferUnderflowException
  - readUTFΔ
```
public <ACS extends Appendable & CharSequence> boolean readUTFΔ(@NotNull
                                                                ACS sb)
                                                         throws net.openhft.chronicle.core.io.IORuntimeException,
                                                                IllegalArgumentException,
                                                                BufferUnderflowException
```
    Specified by:
    
    readUTFΔ in interface StreamingDataInput<Bytes<Void>>
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException
    
    IllegalArgumentException
    
    BufferUnderflowException
  - read8bit
```
public boolean read8bit(@NotNull
                        Bytes b)
                 throws BufferUnderflowException,
                        IllegalStateException,
                        BufferOverflowException
```
    Specified by:
    
    read8bit in interface StreamingDataInput<Bytes<Void>>
    
    Throws:
    
    BufferUnderflowException
    
    IllegalStateException
    
    BufferOverflowException
  - read8bit
```
public <ACS extends Appendable & CharSequence> boolean read8bit(@NotNull
                                                                ACS sb)
                                                         throws net.openhft.chronicle.core.io.IORuntimeException,
                                                                IllegalArgumentException,
                                                                BufferUnderflowException
```
    Specified by:
    
    read8bit in interface StreamingDataInput<Bytes<Void>>
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException
    
    IllegalArgumentException
    
    BufferUnderflowException
  - read8bit
```
public boolean read8bit(@NotNull
                        StringBuilder sb)
                 throws net.openhft.chronicle.core.io.IORuntimeException,
                        BufferUnderflowException
```
    Specified by:
    
    read8bit in interface StreamingDataInput<Bytes<Void>>
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException
    
    BufferUnderflowException
  - read
```
public int read(@NotNull
                byte[] bytes)
```
    Specified by:
    
    read in interface StreamingDataInput<Bytes<Void>>
  - read
```
public int read(@NotNull
                byte[] bytes,
                int off,
                int len)
```
    Specified by:
    
    read in interface StreamingDataInput<Bytes<Void>>
  - read
```
public int read(@NotNull
                char[] bytes,
                int off,
                int len)
```
    Specified by:
    
    read in interface StreamingDataInput<Bytes<Void>>
  - read
```
public void read(@NotNull
                 ByteBuffer buffer)
```
    Specified by:
    
    read in interface StreamingDataInput<Bytes<Void>>
  - read
```
public void read(@NotNull
                 Bytes bytes,
                 int length)
```
    Specified by:
    
    read in interface StreamingDataInput<Bytes<Void>>
  - readEnum
```
@NotNull
public <E extends Enum<E>> E readEnum(@NotNull
                                               Class<E> eClass)
                                        throws net.openhft.chronicle.core.io.IORuntimeException,
                                               BufferUnderflowException
```
    Specified by:
    
    readEnum in interface StreamingDataInput<Bytes<Void>>
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException
    
    BufferUnderflowException
  - readHistogram
```
public void readHistogram(@NotNull
                          net.openhft.chronicle.core.util.Histogram histogram)
```
    Specified by:
    
    readHistogram in interface StreamingDataInput<Bytes<Void>>
  - readWithLength
```
public void readWithLength(Bytes bytes)
```
    Specified by:
    
    readWithLength in interface StreamingDataInput<Bytes<Void>>
  - 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.
    
    Specified by:
    
    lenient in interface StreamingDataInput<Bytes<Void>>
    
    Parameters:
    
    lenient - if true, return nothing rather than error.
  - lenient
```
public boolean lenient()
```
    Specified by:
    
    lenient in interface StreamingDataInput<Bytes<Void>>
  - writeMarshallableLength16
```
public void writeMarshallableLength16(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()
```

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

readStopBitDouble