AbstractBytes (OpenHFT/Chronicle-Bytes 2.21ea14 API)

java.lang.Object
- net.openhft.chronicle.core.io.AbstractReferenceCounted
- - net.openhft.chronicle.bytes.AbstractBytes<Underlying>

All Implemented Interfaces:

Appendable, CharSequence, Bytes<Underlying>, BytesComment<BytesOut<Underlying>>, BytesIn<Underlying>, BytesOut<Underlying>, BytesPrepender<Bytes<Underlying>>, BytesStore<Bytes<Underlying>,Underlying>, ByteStringAppender<Bytes<Underlying>>, RandomDataInput, RandomDataOutput<Bytes<Underlying>>, StreamingCommon<Bytes<Underlying>>, StreamingDataInput<Bytes<Underlying>>, StreamingDataOutput<Bytes<Underlying>>, net.openhft.chronicle.core.io.ReferenceCounted, net.openhft.chronicle.core.io.ReferenceCountedTracer, net.openhft.chronicle.core.io.ReferenceOwner

Direct Known Subclasses:

MappedBytes, UncheckedBytes, VanillaBytes
```
public abstract class AbstractBytes<Underlying>
extends net.openhft.chronicle.core.io.AbstractReferenceCounted
implements Bytes<Underlying>
```

Field Summary

Fields
Modifier and Type	Field and Description
`protected @NotNull BytesStore<Bytes<Underlying>,Underlying>`	`bytesStore`
`protected boolean`	`isPresent`
`protected long`	`readPosition`
`protected long`	`writeLimit`
`protected long`	`writePosition`

Fields inherited from class net.openhft.chronicle.core.io.AbstractReferenceCounted
referenceCounted, WARN_COUNT, WARN_NS

Fields inherited from interface net.openhft.chronicle.bytes.Bytes
DEFAULT_BYTE_BUFFER_CAPACITY, MAX_BYTE_BUFFER_CAPACITY, MAX_CAPACITY, MAX_HEAP_CAPACITY

Fields inherited from interface net.openhft.chronicle.bytes.RandomDataInput
charToString

Fields inherited from interface net.openhft.chronicle.bytes.StreamingDataOutput
JAVA9_STRING_CODER_LATIN, JAVA9_STRING_CODER_UTF16

Method Summary

All 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()`
`@NotNull AbstractBytes`	`append(double d)` Append a double in decimal notation
`int`	`byteCheckSum()` Return the bytes sum of the readable bytes.
`int`	`byteCheckSum(int start, int end)`
`int`	`byteCheckSum(long start, long end)`
`@NotNull BytesStore`	`bytesStore()`
`protected void`	`bytesStore(BytesStore<Bytes<Underlying>,Underlying> bytesStore)`
`boolean`	`canReadDirect(long length)`
`boolean`	`canWriteDirect(long count)`
`long`	`capacity()`
`@NotNull Bytes<Underlying>`	`clear()` Set the readPosition= writePosition = start, writeLimit = capacity
`@NotNull Bytes<Underlying>`	`clearAndPad(long length)` Clear a buffer, with a given padding to allow for prepending later.
`@NotNull Bytes<Underlying>`	`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.
`boolean`	`equals(Object obj)`
`int`	`hashCode()`
`boolean`	`isDirectMemory()`
`int`	`lastDecimalPlaces()`
`void`	`lastDecimalPlaces(int lastDecimalPlaces)` Store the last number of decimal places.
`boolean`	`lenient()`
`void`	`lenient(boolean lenient)` When there is no more data to read, return zero, false and empty string.
`void`	`move(long from, long to, long length)`
`void`	`nativeRead(long position, long address, long size)` expert level method for copying data to native memory.
`void`	`nativeWrite(long address, long position, long size)` expert level method to copy data from native memory into the BytesStore
`default void`	`parse8bit(Appendable buffer, @NotNull StopCharsTester stopCharsTester)` parse text with ISO-8859-1 decoding as character terminated.
`default void`	`parse8bit(Appendable buffer, @NotNull StopCharTester stopCharTester)` parse text with ISO-8859-1 decoding as character terminated.
`default void`	`parse8bit(Bytes buffer, @NotNull StopCharsTester stopCharsTester)`
`default String`	`parse8bit(@NotNull StopCharTester stopCharTester)` parse text with ISO-8859-1 decoding as character terminated.
`default void`	`parse8bit(StringBuilder buffer, @NotNull StopCharsTester stopCharsTester)`
`default @NotNull BigDecimal`	`parseBigDecimal()`
`default @Nullable Boolean`	`parseBoolean()`
`default @Nullable Boolean`	`parseBoolean(@NotNull StopCharTester tester)` Return true or false, or null if it could not be detected as true or false.
`default double`	`parseDouble()` parse text as a double decimal.
`default float`	`parseFloat()` parse text as a float decimal.
`default int`	`parseInt()` parse text as an int.
`default long`	`parseLong()` parse text as a long integer.
`default long`	`parseLongDecimal()` Parse the significant digits of a decimal number.
`default void`	`parseUTF(@NotNull Appendable buffer, @NotNull StopCharsTester stopCharsTester)` Deprecated.
`default void`	`parseUTF(@NotNull Appendable buffer, @NotNull StopCharTester stopCharTester)` Deprecated.
`default @NotNull String`	`parseUTF(@NotNull StopCharTester stopCharTester)` Deprecated.
`default void`	`parseUtf8(@NotNull Appendable buffer, @NotNull StopCharsTester stopCharsTester)` parse text with UTF-8 decoding as one or two character terminated.
`default void`	`parseUtf8(@NotNull Appendable buffer, @NotNull StopCharTester stopCharTester)` parse text with UTF-8 decoding as character terminated.
`default @NotNull String`	`parseUtf8(@NotNull StopCharTester stopCharTester)` parse text with UTF-8 decoding as character terminated.
`int`	`peekUnsignedByte()`
`int`	`peekUnsignedByte(long offset)` Read an unsigned byte at an offset, or -1
`protected void`	`performRelease()`
`@NotNull Bytes<Underlying>`	`prewrite(@NotNull byte[] bytes)` Write backward in binary a byte
`@NotNull Bytes<Underlying>`	`prewrite(@NotNull BytesStore bytes)` Write backward in binary a byte
`@NotNull Bytes<Underlying>`	`prewriteByte(byte i8)` Write backward in binary a byte
`@NotNull Bytes<Underlying>`	`prewriteInt(int i)` Write backward in binary a 4 byte int
`@NotNull Bytes<Underlying>`	`prewriteLong(long l)` Write backward in binary an 8 byte long
`protected long`	`prewriteOffsetPositionMoved(long subtracting)`
`@NotNull Bytes<Underlying>`	`prewriteShort(short i)` Write backward in binary a 2 byte int
`byte`	`readByte()`
`byte`	`readByte(long offset)` Read byte at an offset
`double`	`readDouble()`
`double`	`readDouble(long offset)` Read a double at an offset
`default @NotNull Reader`	`reader()` Access these bytes as an ISO-8859-1 encoded Reader
`float`	`readFloat()`
`float`	`readFloat(long offset)` Read a float at an offset
`int`	`readInt()`
`int`	`readInt(long offset)` Read an int at an offset
`long`	`readLimit()`
`@NotNull Bytes<Underlying>`	`readLimit(long limit)`
`long`	`readLong()`
`long`	`readLong(long offset)` Read a long at an offset
`protected long`	`readOffsetPositionMoved(long adding)`
`long`	`readPosition()` The read position must be start() <= readPosition() && readPosition() <= readLimit() && readPosition < safeLimit()
`@NotNull Bytes<Underlying>`	`readPosition(long position)`
`short`	`readShort()`
`short`	`readShort(long offset)` Read a short at an offset
`@NotNull Bytes<Underlying>`	`readSkip(long bytesToSkip)` Skip a number of bytes by moving the readPosition.
`int`	`readUnsignedByte()`
`int`	`readUnsignedByte(long offset)` Read an unsigned byte at an offset
`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.
`long`	`realCapacity()` Returns the actual capacity that can be potentially read.
`long`	`realWriteRemaining()` Deprecated.
`protected int`	`safeCopySize()`
`default boolean`	`skipTo(@NotNull StopCharTester tester)` Skip text until a terminating character is reached.
`long`	`start()`
`void`	`testAndSetInt(long offset, int expected, int value)`
`@NotNull String`	`toString()`
`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()`
`Underlying`	`underlyingObject()`
`@NotNull Bytes<Underlying>`	`write(@NotNull byte[] bytes, int offset, int length)` Write all data or fail.
`@NotNull Bytes<Underlying>`	`write(long offsetInRDO, byte[] bytes, int offset, int length)`
`void`	`write(long offsetInRDO, ByteBuffer bytes, int offset, int length)`
`@NotNull Bytes<Underlying>`	`write(long writeOffset, RandomDataInput bytes, long readOffset, long length)`
`@NotNull Bytes<Underlying>`	`write(@NotNull RandomDataInput bytes)` Write all data or fail.
`@NotNull Bytes<Underlying>`	`write8bit(@Nullable BytesStore bs)`
`long`	`write8bit(long position, BytesStore bs)` Write the stop bit length and copy the BytesStore
`long`	`write8bit(long position, String s, int start, int length)`
`@NotNull Bytes<Underlying>`	`write8bit(@NotNull String s, int start, int length)`
`@NotNull Bytes<Underlying>`	`writeByte(byte i8)`
`@NotNull Bytes<Underlying>`	`writeByte(long offset, byte i)` Write an unsigned byte at an offset.
`@NotNull Bytes<Underlying>`	`writeDouble(double d)`
`@NotNull Bytes<Underlying>`	`writeDouble(long offset, double d)` Write a double at an offset.
`@NotNull Bytes<Underlying>`	`writeDoubleAndInt(double d, int i)`
`@NotNull Bytes<Underlying>`	`writeFloat(float f)`
`@NotNull Bytes<Underlying>`	`writeFloat(long offset, float d)` Write a float at an offset.
`@NotNull Bytes<Underlying>`	`writeInt(int i)`
`@NotNull Bytes<Underlying>`	`writeInt(long offset, int i)` Write an int at an offset.
`@NotNull Bytes<Underlying>`	`writeIntAdv(int i, int advance)`
`long`	`writeLimit()`
`@NotNull Bytes<Underlying>`	`writeLimit(long limit)`
`@NotNull Bytes<Underlying>`	`writeLong(long i64)` Write a long
`@NotNull Bytes<Underlying>`	`writeLong(long offset, long i)` Write a long at an offset.
`@NotNull Bytes<Underlying>`	`writeLongAdv(long i64, int advance)`
`protected long`	`writeOffsetPositionMoved(long adding)`
`protected long`	`writeOffsetPositionMoved(long adding, long advance)`
`@NotNull Bytes<Underlying>`	`writeOrderedInt(int i)`
`@NotNull Bytes<Underlying>`	`writeOrderedInt(long offset, int i)` Perform a non stalling write with a store barrier.
`@NotNull Bytes<Underlying>`	`writeOrderedLong(long i)`
`@NotNull Bytes<Underlying>`	`writeOrderedLong(long offset, long i)` Perform a non stalling write with a store barrier.
`long`	`writePosition()` The read position must be readPosition() <= writePosition() && writePosition() <= writeLimit()
`@NotNull Bytes<Underlying>`	`writePosition(long position)`
`@NotNull Bytes<Underlying>`	`writeShort(long offset, short i)` Write a short at an offset.
`@NotNull Bytes<Underlying>`	`writeShort(short i16)`
`@NotNull Bytes<Underlying>`	`writeSkip(long bytesToSkip)` Skip a number of bytes by moving the writePosition.
`@NotNull Bytes<Underlying>`	`writeSome(@NotNull ByteBuffer buffer)`
`@NotNull Bytes<Underlying>`	`writeVolatileByte(long offset, byte i8)`
`@NotNull Bytes<Underlying>`	`writeVolatileInt(long offset, int i32)`
`@NotNull Bytes<Underlying>`	`writeVolatileLong(long offset, long i64)`
`@NotNull Bytes<Underlying>`	`writeVolatileShort(long offset, short i16)`

Methods inherited from class net.openhft.chronicle.core.io.AbstractReferenceCounted
assertReferencesReleased, createdHere, disableReferenceTracing, enableReferenceTracing, performReleaseInBackground, refCount, referenceId, release, releaseLast, reserve, reservedBy, reserveTransfer, threadSafetyCheck, throwExceptionIfNotReleased, throwExceptionIfReleased, tryReserve, unmonitor, warnAndReleaseIfNotReleased

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface net.openhft.chronicle.bytes.Bytes
allocateDirect, allocateDirect, allocateElasticDirect, allocateElasticDirect, allocateElasticOnHeap, allocateElasticOnHeap, bytesForRead, copy, copyTo, copyTo, directFrom, elasticByteBuffer, elasticByteBuffer, elasticByteBuffer, elasticHeapByteBuffer, elasticHeapByteBuffer, ensureCapacity, from, from, fromDirect, fromHexString, fromString, indexOf, indexOf, indexOf, indexOf, isClear, isElastic, isEqual, readBigDecimal, readBigInteger, readMarshallableLength16, readWithLength, readWrite, safeLimit, sharedMemory, toHexString, toHexString, toHexString, toString, toString, toString, unchecked, unchecked, unwrite, valueOf, wrapForRead, wrapForRead, wrapForWrite, wrapForWrite, write, writeMarshallableLength16

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

Methods inherited from interface net.openhft.chronicle.bytes.RandomDataOutput
append, append, write, write, writeBoolean, writeByte, writeInt24, writeOrderedDouble, writeOrderedFloat, writeUnsignedByte, writeUnsignedInt, writeUnsignedShort, writeUtf8, writeUtf8Limited, writeVolatileDouble, writeVolatileFloat

Methods inherited from interface java.lang.CharSequence
chars, codePoints

Methods inherited from interface net.openhft.chronicle.bytes.BytesIn
bytesMethodReader, bytesMethodReaderBuilder, readObject

Methods inherited from interface net.openhft.chronicle.bytes.RandomDataInput
addAndGetDouble, addAndGetFloat, addAndGetInt, addAndGetLong, compareUtf8, copyTo, copyTo, createCharToString, fastHash, findByte, parseLong, peekVolatileInt, printable, read, readBoolean, readIncompleteLong, readUnsignedInt, readUnsignedInt24, readUnsignedShort, readUtf8, readUtf8Limited, readUtf8Limited, readVolatileDouble, readVolatileFloat, subBytes, toByteArray, toTemporaryDirectByteBuffer

Methods inherited from interface net.openhft.chronicle.bytes.StreamingDataInput
inputStream, parseHexLong, parseUTF, parseUtf8, parseUtf8, rawReadByte, rawReadInt, rawReadLong, read, read, read, read, read, read, read8bit, read8bit, read8bit, read8bit, readBoolean, readChar, readEnum, readHistogram, readIncompleteLong, readInt24, readLimitToCapacity, readPositionRemaining, readPositionUnlimited, readStopBit, readStopBitChar, readStopBitDecimal, readStopBitDouble, readUnsignedInt, readUnsignedInt24, readUnsignedShort, readUtf8, readUtf8, readUtf8, readUtf8, readUTFΔ, readUTFΔ, readWithLength, readWithLength, readWithLength0, unsafeReadObject, unsafeReadObject

Methods inherited from interface net.openhft.chronicle.bytes.BytesOut
bytesMethodWriter, writeObject

Methods inherited from interface net.openhft.chronicle.bytes.ByteStringAppender
append, append, append, append, append, append, append, append, append, 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, copyFrom, outputStream, rawWriteByte, rawWriteInt, rawWriteLong, unsafeWriteObject, unsafeWriteObject, write, write, write, write, write, write, write8bit, write8bit, write8bit, writeBigDecimal, writeBigInteger, writeBoolean, writeChar, writeEnum, writeHistogram, writeInt24, writePositionRemaining, writeSome, writeStopBit, writeStopBit, writeStopBit, writeStopBitDecimal, writeUnsignedByte, writeUnsignedInt, writeUnsignedInt24, writeUnsignedShort, writeUtf8, writeUtf8, writeUTFΔ, writeWithLength

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

Methods inherited from interface net.openhft.chronicle.bytes.BytesComment
comment, indent, retainsComments

Methods inherited from interface net.openhft.chronicle.core.io.ReferenceCountedTracer
onReleased, onReleased

Field Detail

bytesStore

@NotNull
protected @NotNull BytesStore<Bytes<Underlying>,Underlying> bytesStore

readPosition
```
protected long readPosition
```

writePosition
```
protected long writePosition
```

writeLimit
```
protected long writeLimit
```

isPresent
```
protected boolean isPresent
```

Method Detail

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

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

Returns:

whether it uses direct memory or not.

canReadDirect
```
public boolean canReadDirect(long length)
```
Specified by:

canReadDirect in interface RandomDataInput

move

public void move(long from,
                 long to,
                 long length)
          throws BufferUnderflowException,
                 IllegalStateException,
                 ArithmeticException

Specified by:: move in interface BytesStore<Bytes<Underlying>,Underlying>
Throws:: BufferUnderflowException; IllegalStateException; ArithmeticException

compact
```
@NotNull
public @NotNull Bytes<Underlying> compact()
                                            throws IllegalStateException
```
Description copied from interface: Bytes

Compact these Bytes by moving the readPosition to the start.

Specified by:

compact in interface Bytes<Underlying>

Returns:

this

Throws:

IllegalStateException

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

Set the readPosition= writePosition = start, writeLimit = capacity

Specified by:

clear in interface Bytes<Underlying>

Specified by:

clear in interface StreamingCommon<Bytes<Underlying>>

Returns:

this

Throws:

IllegalStateException

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

Parameters:

length - to pad

Returns:

this

Throws:

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

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

the highest offset or position allowed for this buffer.

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

realCapacity
```
public long realCapacity()
```
Description copied from interface: RandomDataInput

Returns the actual capacity that can be potentially read.

Specified by:

realCapacity in interface Bytes<Underlying>

Specified by:

realCapacity in interface BytesStore<Bytes<Underlying>,Underlying>

Specified by:

realCapacity in interface RandomDataInput

Specified by:

realCapacity in interface StreamingDataOutput<Bytes<Underlying>>

Returns:

the actual capacity available before resizing.

realWriteRemaining
```
@Deprecated
public long realWriteRemaining()
```
Deprecated.

Returns:

writeRemaining with resize

canWriteDirect
```
public boolean canWriteDirect(long count)
```
Specified by:

canWriteDirect in interface StreamingDataOutput<Bytes<Underlying>>

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

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

Returns:

The maximum limit you can set.

underlyingObject
```
@Nullable
public Underlying underlyingObject()
```
Specified by:

underlyingObject in interface BytesStore<Bytes<Underlying>,Underlying>

Returns:

the underlying object being wrapped, if there is one, or null if not.

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

The smallest position allowed in this buffer.

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

Returns:

position to read from.

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

Returns:

position to write to.

compareAndSwapInt

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

Perform a 32-bit CAS at a given offset.

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

testAndSetInt

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

Throws:: BufferOverflowException; IllegalStateException

compareAndSwapLong

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

Perform a 64-bit CAS at a given offset.

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

append

@NotNull
public @NotNull AbstractBytes append(double d)
                                       throws BufferOverflowException,
                                              IllegalStateException

Description copied from interface: ByteStringAppender

Append a double in decimal notation

Specified by:: append in interface ByteStringAppender<Bytes<Underlying>>
Parameters:: d - to append
Returns:: this
Throws:: BufferOverflowException; IllegalStateException

readPosition

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

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

readLimit

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

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

writePosition

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

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

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

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

Specified by:

readSkip in interface StreamingDataInput<Bytes<Underlying>>

Parameters:

bytesToSkip - bytes to skip.

Returns:

this

Throws:

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

IllegalStateException

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

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

Specified by:

uncheckedReadSkipOne in interface StreamingDataInput<Bytes<Underlying>>

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

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

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

Specified by:

writeSkip in interface StreamingDataOutput<Bytes<Underlying>>

Parameters:

bytesToSkip - bytes to skip.

Returns:

this

Throws:

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

IllegalStateException

writeLimit

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

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

performRelease
```
protected void performRelease()
```
Specified by:

performRelease in class net.openhft.chronicle.core.io.AbstractReferenceCounted

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

readUnsignedByte in interface StreamingDataInput<Bytes<Underlying>>

Returns:

the next unsigned 8 bit value or -1;

Throws:

IllegalStateException

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

Read an unsigned byte at an offset

Specified by:

readUnsignedByte in interface RandomDataInput

Parameters:

offset - to read

Returns:

the unsigned byte

Throws:

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

IllegalStateException

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

uncheckedReadUnsignedByte in interface StreamingDataInput<Bytes<Underlying>>

Returns:

the next unsigned 8 bit value or -1;

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

readByte in interface StreamingDataInput<Bytes<Underlying>>

Throws:

IllegalStateException

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

peekUnsignedByte in interface StreamingDataInput<Bytes<Underlying>>

Throws:

IllegalStateException

readShort

public short readShort()
                throws BufferUnderflowException,
                       IllegalStateException

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

readInt

public int readInt()
            throws BufferUnderflowException,
                   IllegalStateException

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

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

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

Specified by:

readVolatileByte in interface RandomDataInput

Parameters:

offset - to read

Returns:

the byte value

Throws:

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

IllegalStateException

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

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

Specified by:

readVolatileShort in interface RandomDataInput

Parameters:

offset - to read

Returns:

the short value

Throws:

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

IllegalStateException

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

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

Specified by:

readVolatileInt in interface RandomDataInput

Parameters:

offset - to read

Returns:

the int value

Throws:

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

IllegalStateException

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

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

Specified by:

readVolatileLong in interface RandomDataInput

Parameters:

offset - to read

Returns:

the long value

Throws:

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

IllegalStateException

readLong

public long readLong()
              throws BufferUnderflowException,
                     IllegalStateException

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

readFloat

public float readFloat()
                throws BufferUnderflowException,
                       IllegalStateException

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

readDouble

public double readDouble()
                  throws BufferUnderflowException,
                         IllegalStateException

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

readVolatileInt

public int readVolatileInt()
                    throws BufferUnderflowException,
                           IllegalStateException

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

readVolatileLong

public long readVolatileLong()
                      throws BufferUnderflowException,
                             IllegalStateException

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

readOffsetPositionMoved

protected long readOffsetPositionMoved(long adding)
                                throws BufferUnderflowException,
                                       IllegalStateException

Throws:: BufferUnderflowException; IllegalStateException