UncheckedNativeBytes (OpenHFT/Chronicle-Bytes 2.21.93 API)

java.lang.Object
- net.openhft.chronicle.core.io.AbstractReferenceCounted
- - net.openhft.chronicle.bytes.UncheckedNativeBytes<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>>, ByteStringParser<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
```
public class UncheckedNativeBytes<Underlying>
extends net.openhft.chronicle.core.io.AbstractReferenceCounted
implements Bytes<Underlying>
```
Fast unchecked version of AbstractBytes

Field Summary

Fields
Modifier and Type	Field and Description
`protected @NotNull BytesStore<?,Underlying>`	`bytesStore`
`protected long`	`capacity`
`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

Constructor Summary

Constructors
Constructor and Description

UncheckedNativeBytes(@NotNull Bytes<Underlying> underlyingBytes)

Constructors
Constructor and Description
`UncheckedNativeBytes(@NotNull Bytes<Underlying> underlyingBytes)`

Method Summary

All Methods Instance Methods Concrete 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 Bytes<Underlying>`	`append8bit(@NotNull CharSequence cs)` Append a String to the Bytes in ISO-8859-1
`@NotNull Bytes<Underlying>`	`appendUtf8(char[] chars, int offset, int length)`
`int`	`byteCheckSum()` Returns the bytes sum of the readable bytes in this BytesStore.
`@Nullable BytesStore`	`bytesStore()`
`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.
`@NotNull BytesStore<Bytes<Underlying>,Underlying>`	`copy()`
`void`	`ensureCapacity(long desiredCapacity)` Grows the buffer if the buffer is elastic, if the buffer is not elastic and there is not enough capacity then this method will throws `BufferOverflowException`
`boolean`	`equals(Object obj)`
`boolean`	`equalsBytes(@NotNull Bytes b2, long remaining)`
`int`	`hashCode()`
`boolean`	`isDirectMemory()`
`boolean`	`isElastic()` Returns if this Bytes is elastic.
`int`	`lastDecimalPlaces()`
`void`	`lastDecimalPlaces(int lastDecimalPlaces)` Store the last number of decimal places.
`boolean`	`lastNumberHadDigits()`
`void`	`lastNumberHadDigits(boolean lastNumberHadDigits)`
`boolean`	`lenient()`
`void`	`lenient(boolean lenient)` When there is no more data to read, return zero, `false` and empty string.
`void`	`move(long from, long to, long length)`
`void`	`nativeRead(long position, long address, long size)` expert level method for copying data to native memory.
`void`	`nativeWrite(long address, long position, long size)` expert level method to copy data from native memory into the BytesStore
`int`	`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 i64)` Write backward in binary an 8 byte long
`protected long`	`prewriteOffsetPositionMoved(long substracting)`
`@NotNull Bytes<Underlying>`	`prewriteShort(short i16)` Write backward in binary a 2 byte int
`long`	`rawCopy(@NotNull RandomDataInput bytes, long offset, long length)`
`byte`	`readByte()`
`byte`	`readByte(long offset)` Read byte at an offset
`double`	`readDouble()`
`double`	`readDouble(long offset)` Read a double at an offset
`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()`
`void`	`testAndSetInt(long offset, int expected, int value)`
`@NotNull String`	`toString()`
`boolean`	`unchecked()`
`@NotNull Bytes<Underlying>`	`unchecked(boolean unchecked)` Returns a Bytes which is optionally unchecked.
`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, @NotNull ByteBuffer bytes, int offset, int length)`
`@NotNull Bytes<Underlying>`	`write(long writeOffset, @NotNull RandomDataInput bytes, long readOffset, long length)`
`@NotNull Bytes<Underlying>`	`write(@NotNull RandomDataInput bytes)` Write all data or fail.
`@NotNull Bytes<Underlying>`	`write(@NotNull RandomDataInput bytes, long offset, long length)` Write all data or fail.
`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 write 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, clearUsedByThread, 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, copyTo, copyTo, directFrom, elasticByteBuffer, elasticByteBuffer, elasticByteBuffer, elasticHeapByteBuffer, elasticHeapByteBuffer, forFieldGroup, from, from, fromDirect, fromHexString, fromString, indexOf, indexOf, indexOf, indexOf, isClear, isEqual, readBigDecimal, readBigInteger, readMarshallableLength16, readWithLength, readWrite, safeLimit, sharedMemory, toHexString, toHexString, toHexString, toString, toString, toString, unwrite, valueOf, wrapForRead, wrapForRead, wrapForWrite, wrapForWrite, write, writeMarshallableLength16

Methods inherited from interface net.openhft.chronicle.bytes.BytesStore
addAndGetDoubleNotAtomic, addAndGetFloatNotAtomic, addAndGetIntNotAtomic, addAndGetShortNotAtomic, addAndGetUnsignedByteNotAtomic, byteCheckSum, bytesForWrite, charAt, cipher, cipher, contentEquals, elasticByteBuffer, empty, endsWith, equalBytes, forFields, from, hash, inside, inside, isEmpty, isEqual, lazyNativeBytesStoreWithFixedCapacity, length, nativePointer, nativeStore, nativeStoreWithFixedCapacity, 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, canReadDirect, 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.ByteStringParser
parse8bit, parse8bit, parse8bit, parse8bit, parse8bit, parseBigDecimal, parseBoolean, parseBoolean, parseDouble, parseFloat, parseInt, parseLong, parseLongDecimal, parseUTF, parseUTF, parseUTF, parseUtf8, parseUtf8, parseUtf8, reader, skipTo

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, readPositionForHeader, readPositionRemaining, readPositionUnlimited, readStopBit, readStopBitChar, readStopBitDecimal, readStopBitDouble, readUnsignedInt, readUnsignedInt24, readUnsignedShort, readUtf8, readUtf8, readUtf8, readUtf8, readUTFΔ, readUTFΔ, readWithLength, readWithLength, readWithLength0, unsafeRead, unsafeReadObject, unsafeReadObject

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

Methods inherited from interface net.openhft.chronicle.bytes.ByteStringAppender
append, append, append, append, append, append, append, append, append, append, append8bit, append8bit, append8bit, append8bit, appendBase, appendBase16, appendBase16, appendDateMillis, appendDecimal, appendTimeMillis, writer

Methods inherited from interface net.openhft.chronicle.bytes.StreamingDataOutput
alignBy, appendUtf8, appendUtf8, appendUtf8, appendUtf8, appendUtf8, canWriteDirect, copyFrom, outputStream, rawWriteByte, rawWriteInt, rawWriteLong, unsafeWrite, unsafeWriteObject, unsafeWriteObject, write, write, write, write, write, write8bit, write8bit, write8bit, writeBigDecimal, writeBigInteger, writeBoolean, writeChar, writeEnum, writeHistogram, writeInt24, writePositionForHeader, 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, onReleased

- Field Detail
  - capacity
```
protected final long capacity
```
  - bytesStore
```
@NotNull
protected @NotNull BytesStore<?,Underlying> bytesStore
```
  - readPosition
```
protected long readPosition
```
  - writePosition
```
protected long writePosition
```
  - writeLimit
```
protected long writeLimit
```
- Constructor Detail
  - UncheckedNativeBytes
```
public UncheckedNativeBytes(@NotNull
                            @NotNull Bytes<Underlying> underlyingBytes)
                     throws IllegalStateException
```
    Throws:
    
    IllegalStateException
- Method Detail
  - ensureCapacity
```
public void ensureCapacity(long desiredCapacity)
                    throws IllegalArgumentException,
                           IllegalStateException
```
    Description copied from interface: Bytes
    
    Grows 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<Underlying>
    
    Parameters:
    
    desiredCapacity - the capacity that you required
    
    Throws:
    
    IllegalArgumentException - if the buffer is not elastic and there is not enough space
    
    IllegalStateException
  - unchecked
```
public boolean unchecked()
```
    Specified by:
    
    unchecked in interface Bytes<Underlying>
  - isDirectMemory
```
public boolean isDirectMemory()
```
    Specified by:
    
    isDirectMemory in interface BytesStore<Bytes<Underlying>,Underlying>
    
    Returns:
    
    whether it uses direct memory or not.
  - unchecked
```
@NotNull
public @NotNull Bytes<Underlying> unchecked(boolean unchecked)
```
    Description copied from interface: Bytes
    
    Returns a Bytes which is optionally unchecked. This allows bounds checks to be turned off. Note: this means that the result is no longer elastic, even if this is elastic.
    
    Specified by:
    
    unchecked in interface Bytes<Underlying>
    
    Parameters:
    
    unchecked - if true, minimal bounds checks will be performed
    
    Returns:
    
    Bytes without bounds checking
  - move
```
public void move(long from,
                 long to,
                 long length)
          throws IllegalStateException,
                 BufferUnderflowException
```
    Specified by:
    
    move in interface BytesStore<Bytes<Underlying>,Underlying>
    
    Throws:
    
    IllegalStateException
    
    BufferUnderflowException
  - compact
```
@NotNull
public @NotNull Bytes<Underlying> compact()
```
    Description copied from interface: Bytes
    
    Compact these Bytes by moving the readPosition to the start.
    
    Specified by:
    
    compact in interface Bytes<Underlying>
    
    Returns:
    
    this
  - readPosition
```
@NotNull
public @NotNull Bytes<Underlying> readPosition(long position)
```
    Specified by:
    
    readPosition in interface StreamingDataInput<Bytes<Underlying>>
  - readLimit
```
@NotNull
public @NotNull Bytes<Underlying> readLimit(long limit)
```
    Specified by:
    
    readLimit in interface StreamingDataInput<Bytes<Underlying>>
  - writePosition
```
@NotNull
public @NotNull Bytes<Underlying> writePosition(long position)
```
    Specified by:
    
    writePosition in interface StreamingDataOutput<Bytes<Underlying>>
  - readSkip
```
@NotNull
public @NotNull Bytes<Underlying> readSkip(long bytesToSkip)
```
    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
  - 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
  - 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)
```
    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. This can be negative.
    
    Returns:
    
    this
  - writeLimit
```
@NotNull
public @NotNull Bytes<Underlying> writeLimit(long limit)
```
    Specified by:
    
    writeLimit in interface StreamingDataOutput<Bytes<Underlying>>
  - copy
```
@NotNull
public @NotNull BytesStore<Bytes<Underlying>,Underlying> copy()
```
    Specified by:
    
    copy in interface Bytes<Underlying>
    
    Specified by:
    
    copy in interface BytesStore<Bytes<Underlying>,Underlying>
    
    Returns:
    
    a copy of this Bytes from position() to limit().
  - isElastic
```
public boolean isElastic()
```
    Description copied from interface: Bytes
    
    Returns if this Bytes is elastic. I.e. it can resize when more data is written than it's Bytes.realCapacity().
    
    Specified by:
    
    isElastic in interface Bytes<Underlying>
    
    Returns:
    
    if this Bytes is elastic
  - readOffsetPositionMoved
```
protected long readOffsetPositionMoved(long adding)
```
  - writeOffsetPositionMoved
```
protected long writeOffsetPositionMoved(long adding)
```
  - writeOffsetPositionMoved
```
protected long writeOffsetPositionMoved(long adding,
                                        long advance)
```
  - prewriteOffsetPositionMoved
```
protected long prewriteOffsetPositionMoved(long substracting)
```
  - write
```
@NotNull
public @NotNull Bytes<Underlying> write(@NotNull
                                                 @NotNull RandomDataInput bytes,
                                                 long offset,
                                                 long length)
                                          throws BufferUnderflowException,
                                                 BufferOverflowException,
                                                 IllegalStateException
```
    Description copied from interface: StreamingDataOutput
    
    Write all data or fail.
    
    Specified by:
    
    write in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferUnderflowException
    
    BufferOverflowException
    
    IllegalStateException
  - rawCopy
```
public long rawCopy(@NotNull
                    @NotNull RandomDataInput bytes,
                    long offset,
                    long length)
             throws BufferOverflowException,
                    BufferUnderflowException,
                    IllegalStateException
```
    Throws:
    
    BufferOverflowException
    
    BufferUnderflowException
    
    IllegalStateException
  - clear
```
@NotNull
public @NotNull Bytes<Underlying> clear()
```
    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
  - 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
```
public long realWriteRemaining()
```
    Returns:
    
    writeRemaining with resize
  - 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.
  - 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 write 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
  - performRelease
```
protected void performRelease()
                       throws IllegalStateException
```
    Specified by:
    
    performRelease in class net.openhft.chronicle.core.io.AbstractReferenceCounted
    
    Throws:
    
    IllegalStateException
  - readUnsignedByte
```
public int readUnsignedByte()
```
    Specified by:
    
    readUnsignedByte in interface StreamingDataInput<Bytes<Underlying>>
    
    Returns:
    
    the next unsigned 8 bit value or -1;
  - 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()
```
    Specified by:
    
    readByte in interface StreamingDataInput<Bytes<Underlying>>
  - peekUnsignedByte
```
public int peekUnsignedByte()
```
    Specified by:
    
    peekUnsignedByte in interface StreamingDataInput<Bytes<Underlying>>
  - readShort
```
public short readShort()
```
    Specified by:
    
    readShort in interface StreamingDataInput<Bytes<Underlying>>
  - readInt
```
public int readInt()
```
    Specified by:
    
    readInt in interface StreamingDataInput<Bytes<Underlying>>
  - readLong
```
public long readLong()
```
    Specified by:
    
    readLong in interface StreamingDataInput<Bytes<Underlying>>
  - readFloat
```
public float readFloat()
```
    Specified by:
    
    readFloat in interface StreamingDataInput<Bytes<Underlying>>
  - readDouble
```
public double readDouble()
```
    Specified by:
    
    readDouble in interface StreamingDataInput<Bytes<Underlying>>
  - readVolatileInt
```
public int readVolatileInt()
```
    Specified by:
    
    readVolatileInt in interface StreamingDataInput<Bytes<Underlying>>
  - readVolatileLong
```
public long readVolatileLong()
```
    Specified by:
    
    readVolatileLong in interface StreamingDataInput<Bytes<Underlying>>
  - writeByte
```
@NotNull
public @NotNull Bytes<Underlying> writeByte(long offset,
                                                     byte i)
                                              throws BufferOverflowException,
                                                     IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Write an unsigned byte at an offset.
    
    Specified by:
    
    writeByte in interface RandomDataOutput<Bytes<Underlying>>
    
    Parameters:
    
    offset - to write to
    
    i - the value
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
    
    IllegalStateException
  - writeShort
```
@NotNull
public @NotNull Bytes<Underlying> writeShort(long offset,
                                                      short i)
                                               throws BufferOverflowException,
                                                      IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Write a short at an offset.
    
    Specified by:
    
    writeShort in interface RandomDataOutput<Bytes<Underlying>>
    
    Parameters:
    
    offset - to write to
    
    i - the value
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
    
    IllegalStateException
  - writeInt
```
@NotNull
public @NotNull Bytes<Underlying> writeInt(long offset,
                                                    int i)
                                             throws BufferOverflowException,
                                                    IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Write an int at an offset.
    
    Specified by:
    
    writeInt in interface RandomDataOutput<Bytes<Underlying>>
    
    Parameters:
    
    offset - to write to
    
    i - the value
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
    
    IllegalStateException
  - writeOrderedInt
```
@NotNull
public @NotNull Bytes<Underlying> writeOrderedInt(long offset,
                                                           int i)
                                                    throws BufferOverflowException,
                                                           IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Perform a non stalling write with a store barrier.
    
    Specified by:
    
    writeOrderedInt in interface RandomDataOutput<Bytes<Underlying>>
    
    Parameters:
    
    offset - to write to
    
    i - value to write
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
    
    IllegalStateException
  - writeLong
```
@NotNull
public @NotNull Bytes<Underlying> writeLong(long offset,
                                                     long i)
                                              throws BufferOverflowException,
                                                     IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Write a long at an offset.
    
    Specified by:
    
    writeLong in interface RandomDataOutput<Bytes<Underlying>>
    
    Parameters:
    
    offset - to write to
    
    i - the value
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
    
    IllegalStateException
  - writeOrderedLong
```
@NotNull
public @NotNull Bytes<Underlying> writeOrderedLong(long offset,
                                                            long i)
                                                     throws BufferOverflowException,
                                                            IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Perform a non stalling write with a store barrier.
    
    Specified by:
    
    writeOrderedLong in interface RandomDataOutput<Bytes<Underlying>>
    
    Parameters:
    
    offset - to write to
    
    i - value to write
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
  - writeFloat
```
@NotNull
public @NotNull Bytes<Underlying> writeFloat(long offset,
                                                      float d)
                                               throws BufferOverflowException,
                                                      IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Write a float at an offset.
    
    Specified by:
    
    writeFloat in interface RandomDataOutput<Bytes<Underlying>>
    
    Parameters:
    
    offset - to write to
    
    d - the value
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
    
    IllegalStateException
  - writeDouble
```
@NotNull
public @NotNull Bytes<Underlying> writeDouble(long offset,
                                                       double d)
                                                throws BufferOverflowException,
                                                       IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Write a double at an offset.
    
    Specified by:
    
    writeDouble in interface RandomDataOutput<Bytes<Underlying>>
    
    Parameters:
    
    offset - to write to
    
    d - the value
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
    
    IllegalStateException
  - writeVolatileByte
```
@NotNull
public @NotNull Bytes<Underlying> writeVolatileByte(long offset,
                                                             byte i8)
                                                      throws BufferOverflowException,
                                                             IllegalStateException
```
    Specified by:
    
    writeVolatileByte in interface RandomDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
  - writeVolatileShort
```
@NotNull
public @NotNull Bytes<Underlying> writeVolatileShort(long offset,
                                                              short i16)
                                                       throws BufferOverflowException,
                                                              IllegalStateException
```
    Specified by:
    
    writeVolatileShort in interface RandomDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
  - writeVolatileInt
```
@NotNull
public @NotNull Bytes<Underlying> writeVolatileInt(long offset,
                                                            int i32)
                                                     throws BufferOverflowException,
                                                            IllegalStateException
```
    Specified by:
    
    writeVolatileInt in interface RandomDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
  - writeVolatileLong
```
@NotNull
public @NotNull Bytes<Underlying> writeVolatileLong(long offset,
                                                             long i64)
                                                      throws BufferOverflowException,
                                                             IllegalStateException
```
    Specified by:
    
    writeVolatileLong in interface RandomDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
  - write
```
@NotNull
public @NotNull Bytes<Underlying> write(long offsetInRDO,
                                                 byte[] bytes,
                                                 int offset,
                                                 int length)
                                          throws BufferOverflowException,
                                                 IllegalStateException
```
    Specified by:
    
    write in interface RandomDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
  - write
```
public void write(long offsetInRDO,
                  @NotNull
                  @NotNull ByteBuffer bytes,
                  int offset,
                  int length)
           throws BufferOverflowException,
                  IllegalStateException
```
    Specified by:
    
    write in interface RandomDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
  - write
```
@NotNull
public @NotNull Bytes<Underlying> write(long writeOffset,
                                                 @NotNull
                                                 @NotNull RandomDataInput bytes,
                                                 long readOffset,
                                                 long length)
                                          throws BufferUnderflowException,
                                                 BufferOverflowException,
                                                 IllegalStateException
```
    Specified by:
    
    write in interface RandomDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferUnderflowException
    
    BufferOverflowException
    
    IllegalStateException
  - readByte
```
public byte readByte(long offset)
```
    Description copied from interface: RandomDataInput
    
    Read byte at an offset
    
    Specified by:
    
    readByte in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the byte
  - readUnsignedByte
```
public int readUnsignedByte(long offset)
```
    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
  - 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)
```
    Description copied from interface: RandomDataInput
    
    Read a short at an offset
    
    Specified by:
    
    readShort in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the short
  - readInt
```
public int readInt(long offset)
```
    Description copied from interface: RandomDataInput
    
    Read an int at an offset
    
    Specified by:
    
    readInt in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the int
  - readLong
```
public long readLong(long offset)
```
    Description copied from interface: RandomDataInput
    
    Read a long at an offset
    
    Specified by:
    
    readLong in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the long
  - readFloat
```
public float readFloat(long offset)
```
    Description copied from interface: RandomDataInput
    
    Read a float at an offset
    
    Specified by:
    
    readFloat in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the float
  - readDouble
```
public double readDouble(long offset)
```
    Description copied from interface: RandomDataInput
    
    Read a double at an offset
    
    Specified by:
    
    readDouble in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the double
  - writeByte
```
@NotNull
public @NotNull Bytes<Underlying> writeByte(byte i8)
```
    Specified by:
    
    writeByte in interface StreamingDataOutput<Bytes<Underlying>>
  - prewriteByte
```
@NotNull
public @NotNull Bytes<Underlying> prewriteByte(byte i8)
```
    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<Underlying>>
    
    Parameters:
    
    i8 - byte to prepend to.
  - writeShort
```
@NotNull
public @NotNull Bytes<Underlying> writeShort(short i16)
                                               throws IllegalStateException
```
    Specified by:
    
    writeShort in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    IllegalStateException
  - prewriteShort
```
@NotNull
public @NotNull Bytes<Underlying> prewriteShort(short i16)
                                                  throws IllegalStateException
```
    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<Underlying>>
    
    Parameters:
    
    i16 - short to prepend to.
    
    Throws:
    
    IllegalStateException
  - writeInt
```
@NotNull
public @NotNull Bytes<Underlying> writeInt(int i)
                                             throws IllegalStateException
```
    Specified by:
    
    writeInt in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    IllegalStateException
  - writeIntAdv
```
@NotNull
public @NotNull Bytes<Underlying> writeIntAdv(int i,
                                                       int advance)
                                                throws IllegalStateException
```
    Specified by:
    
    writeIntAdv in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    IllegalStateException
  - prewriteInt
```
@NotNull
public @NotNull Bytes<Underlying> prewriteInt(int i)
                                                throws IllegalStateException
```
    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<Underlying>>
    
    Parameters:
    
    i - integer to prepend to.
    
    Throws:
    
    IllegalStateException
  - writeLong
```
@NotNull
public @NotNull Bytes<Underlying> writeLong(long i64)
                                              throws IllegalStateException
```
    Description copied from interface: StreamingDataOutput
    
    Write a long
    
    Specified by:
    
    writeLong in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    IllegalStateException
  - writeLongAdv
```
@NotNull
public @NotNull Bytes<Underlying> writeLongAdv(long i64,
                                                        int advance)
                                                 throws IllegalStateException
```
    Specified by:
    
    writeLongAdv in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    IllegalStateException
  - prewriteLong
```
@NotNull
public @NotNull Bytes<Underlying> prewriteLong(long i64)
                                                 throws IllegalStateException
```
    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<Underlying>>
    
    Parameters:
    
    i64 - long to prepend to.
    
    Throws:
    
    IllegalStateException
  - writeFloat
```
@NotNull
public @NotNull Bytes<Underlying> writeFloat(float f)
                                               throws IllegalStateException
```
    Specified by:
    
    writeFloat in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    IllegalStateException
  - writeDouble
```
@NotNull
public @NotNull Bytes<Underlying> writeDouble(double d)
                                                throws IllegalStateException
```
    Specified by:
    
    writeDouble in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    IllegalStateException
  - writeDoubleAndInt
```
@NotNull
public @NotNull Bytes<Underlying> writeDoubleAndInt(double d,
                                                             int i)
                                                      throws IllegalStateException
```
    Specified by:
    
    writeDoubleAndInt in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    IllegalStateException
  - write
```
@NotNull
public @NotNull Bytes<Underlying> write(@NotNull
                                                 @NotNull byte[] bytes,
                                                 int offset,
                                                 int length)
                                          throws BufferOverflowException,
                                                 IllegalStateException,
                                                 ArrayIndexOutOfBoundsException
```
    Description copied from interface: StreamingDataOutput
    
    Write all data or fail.
    
    Specified by:
    
    write in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
    
    ArrayIndexOutOfBoundsException
  - prewrite
```
@NotNull
public @NotNull Bytes<Underlying> prewrite(@NotNull
                                                    @NotNull byte[] bytes)
                                             throws IllegalStateException,
                                                    BufferOverflowException
```
    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<Underlying>>
    
    Parameters:
    
    bytes - to prepend to.
    
    Throws:
    
    IllegalStateException
    
    BufferOverflowException
  - prewrite
```
@NotNull
public @NotNull Bytes<Underlying> prewrite(@NotNull
                                                    @NotNull BytesStore bytes)
                                             throws IllegalStateException,
                                                    BufferOverflowException
```
    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<Underlying>>
    
    Parameters:
    
    bytes - to prepend to.
    
    Throws:
    
    IllegalStateException
    
    BufferOverflowException
  - writeSome
```
@NotNull
public @NotNull Bytes<Underlying> writeSome(@NotNull
                                                     @NotNull ByteBuffer buffer)
                                              throws IllegalStateException
```
    Specified by:
    
    writeSome in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    IllegalStateException
  - writeOrderedInt
```
@NotNull
public @NotNull Bytes<Underlying> writeOrderedInt(int i)
                                                    throws IllegalStateException
```
    Specified by:
    
    writeOrderedInt in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    IllegalStateException
  - writeOrderedLong
```
@NotNull
public @NotNull Bytes<Underlying> writeOrderedLong(long i)
                                                     throws IllegalStateException
```
    Specified by:
    
    writeOrderedLong in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    IllegalStateException
  - addressForRead
```
public long addressForRead(long offset)
                    throws BufferUnderflowException
```
    Obtain the underlying addressForRead. This is for expert users only.
    
    Parameters:
    
    offset - within this buffer. addressForRead(start()) is the actual addressForRead of the first byte.
    
    Returns:
    
    the underlying addressForRead of the buffer
    
    Throws:
    
    BufferUnderflowException - if the offset is before the start() or the after the capacity()
  - addressForWrite
```
public long addressForWrite(long offset)
                     throws BufferOverflowException
```
    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:
    
    BufferOverflowException - if the offset is before the start() or the after the capacity()
  - addressForWritePosition
```
public long addressForWritePosition()
                             throws UnsupportedOperationException,
                                    BufferOverflowException
```
    Throws:
    
    UnsupportedOperationException
    
    BufferOverflowException
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - equalsBytes
```
public boolean equalsBytes(@NotNull
                           @NotNull Bytes b2,
                           long remaining)
                    throws IllegalStateException
```
    Throws:
    
    IllegalStateException
  - toString
```
@NotNull
public @NotNull String toString()
```
    Specified by:
    
    toString in interface CharSequence
    
    Overrides:
    
    toString in class net.openhft.chronicle.core.io.AbstractReferenceCounted
  - 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<Underlying>>
    
    Parameters:
    
    lenient - if true, return nothing rather than error.
  - lenient
```
public boolean lenient()
```
    Specified by:
    
    lenient in interface StreamingDataInput<Bytes<Underlying>>
  - nativeRead
```
public void nativeRead(long position,
                       long address,
                       long size)
                throws IllegalStateException,
                       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:
    
    IllegalStateException - if released
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - nativeWrite
```
public void nativeWrite(long address,
                        long position,
                        long size)
                 throws IllegalStateException,
                        BufferOverflowException
```
    Description copied from interface: RandomDataOutput
    
    expert level method to copy data from native memory into the BytesStore
    
    Specified by:
    
    nativeWrite in interface RandomDataOutput<Bytes<Underlying>>
    
    Parameters:
    
    address - in native memory to copy from
    
    position - in BytesStore to copy to
    
    size - in bytes
    
    Throws:
    
    IllegalStateException
    
    BufferOverflowException
  - bytesStore
```
@Nullable
public @Nullable BytesStore bytesStore()
```
    Specified by:
    
    bytesStore in interface Bytes<Underlying>
    
    Specified by:
    
    bytesStore in interface BytesStore<Bytes<Underlying>,Underlying>
    
    Returns:
    
    the ByteStore this Bytes wraps.
  - byteCheckSum
```
public int byteCheckSum()
                 throws net.openhft.chronicle.core.io.IORuntimeException
```
    Description copied from interface: BytesStore
    
    Returns the bytes sum of the readable bytes in this BytesStore.
    
    Specified by:
    
    byteCheckSum in interface BytesStore<Bytes<Underlying>,Underlying>
    
    Returns:
    
    unsigned bytes sum
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException
  - append8bit
```
@NotNull
public @NotNull Bytes<Underlying> append8bit(@NotNull
                                                      @NotNull CharSequence cs)
                                               throws BufferOverflowException,
                                                      BufferUnderflowException,
                                                      IllegalStateException
```
    Description copied from interface: ByteStringAppender
    
    Append a String to the Bytes in ISO-8859-1
    
    Specified by:
    
    append8bit in interface ByteStringAppender<Bytes<Underlying>>
    
    Parameters:
    
    cs - to write
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - If the string as too large to write in the capacity available
    
    BufferUnderflowException - if the capacity of the underlying buffer was exceeded
    
    IllegalStateException
  - appendUtf8
```
@NotNull
public @NotNull Bytes<Underlying> appendUtf8(char[] chars,
                                                      int offset,
                                                      int length)
                                               throws BufferOverflowException,
                                                      IllegalArgumentException,
                                                      IllegalStateException
```
    Specified by:
    
    appendUtf8 in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    IllegalArgumentException
    
    IllegalStateException
  - lastDecimalPlaces
```
public int lastDecimalPlaces()
```
    Specified by:
    
    lastDecimalPlaces in interface ByteStringParser<Bytes<Underlying>>
    
    Returns:
    
    the last number of decimal places for parseDouble or parseLongDecimal
  - lastDecimalPlaces
```
public void lastDecimalPlaces(int lastDecimalPlaces)
```
    Description copied from interface: ByteStringParser
    
    Store the last number of decimal places. If
    
    Specified by:
    
    lastDecimalPlaces in interface ByteStringParser<Bytes<Underlying>>
    
    Parameters:
    
    lastDecimalPlaces - set the number of decimal places if positive, otherwise 0.
  - lastNumberHadDigits
```
public boolean lastNumberHadDigits()
```
    Specified by:
    
    lastNumberHadDigits in interface ByteStringParser<Bytes<Underlying>>
    
    Returns:
    
    the last number had digits
  - lastNumberHadDigits
```
public void lastNumberHadDigits(boolean lastNumberHadDigits)
```
    Specified by:
    
    lastNumberHadDigits in interface ByteStringParser<Bytes<Underlying>>
    
    Parameters:
    
    lastNumberHadDigits - set the last number had digits
  - write
```
@NotNull
public @NotNull Bytes<Underlying> write(@NotNull
                                                 @NotNull RandomDataInput bytes)
                                          throws IllegalStateException
```
    Description copied from interface: StreamingDataOutput
    
    Write all data or fail.
    
    Specified by:
    
    write in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    IllegalStateException
  - write8bit
```
public long write8bit(long position,
                      BytesStore bs)
```
    Description copied from interface: RandomDataOutput
    
    Write the stop bit length and copy the BytesStore
    
    Specified by:
    
    write8bit in interface RandomDataOutput<Bytes<Underlying>>
    
    Parameters:
    
    position - to write
    
    bs - to copy.
    
    Returns:
    
    the offset after the char sequence written, in this RandomDataOutput
  - write8bit
```
public long write8bit(long position,
                      String s,
                      int start,
                      int length)
```
    Specified by:
    
    write8bit in interface RandomDataOutput<Bytes<Underlying>>
  - write8bit
```
public Bytes<Underlying> write8bit(@Nullable
                                   @Nullable BytesStore bs)
                            throws BufferOverflowException,
                                   IllegalStateException,
                                   BufferUnderflowException
```
    Specified by:
    
    write8bit in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
    
    BufferUnderflowException
  - write8bit
```
@NotNull
public @NotNull Bytes<Underlying> write8bit(@NotNull
                                                     @NotNull String s,
                                                     int start,
                                                     int length)
```
    Specified by:
    
    write8bit in interface StreamingDataOutput<Bytes<Underlying>>

Class UncheckedNativeBytes<Underlying>

Field Summary

Fields inherited from class net.openhft.chronicle.core.io.AbstractReferenceCounted

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 net.openhft.chronicle.core.io.AbstractReferenceCounted

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

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

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

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

Field Detail

capacity

bytesStore

readPosition

writePosition

writeLimit

Constructor Detail

UncheckedNativeBytes

Method Detail

ensureCapacity

unchecked

isDirectMemory

unchecked

move

compact

readPosition

readLimit

writePosition

readSkip

readVolatileByte

readVolatileShort

readVolatileInt

readVolatileLong

uncheckedReadSkipOne

uncheckedReadSkipBackOne

writeSkip

writeLimit

copy

isElastic

readOffsetPositionMoved

writeOffsetPositionMoved

writeOffsetPositionMoved

prewriteOffsetPositionMoved

write

rawCopy

clear

clearAndPad

readLimit

writeLimit

realCapacity

realWriteRemaining

capacity

underlyingObject

readPosition

writePosition

compareAndSwapInt

testAndSetInt

compareAndSwapLong

performRelease

readUnsignedByte

uncheckedReadUnsignedByte

readByte

peekUnsignedByte

readShort

readInt

readLong