AbstractBytes (OpenHFT/Chronicle-Bytes 1.1.13 API)

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

All Implemented Interfaces:

Closeable, Appendable, AutoCloseable, CharSequence, Bytes<Underlying>, BytesPrepender<Bytes<Underlying>>, BytesStore<Bytes<Underlying>,Underlying>, ByteStringAppender<Bytes<Underlying>>, RandomDataInput, RandomDataOutput<Bytes<Underlying>>, StreamingDataInput<Bytes<Underlying>>, StreamingDataOutput<Bytes<Underlying>>, net.openhft.chronicle.core.ReferenceCounted

Direct Known Subclasses:

MappedBytes, UncheckedBytes, VanillaBytes
```
public abstract class AbstractBytes<Underlying>
extends Object
implements Bytes<Underlying>
```

Field Summary

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

Fields inherited from interface net.openhft.chronicle.bytes.Bytes
MAX_CAPACITY

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

Method Summary

All Methods Instance Methods Concrete Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`long`	`address(long offset)` Obtain the underlying address.
`default ByteOrder`	`byteOrder()`
`BytesStore`	`bytesStore()`
`long`	`capacity()`
`Bytes<Underlying>`	`clear()` Set the readPosition= writePosition = start, writeLimit = capacity
`Bytes<Underlying>`	`clearAndPad(long length)` Clear a buffer, with a given padding to allow for prepending later.
`default boolean`	`compareAndSwapDouble(long offset, double expected, double value)` Perform a 64-bit double CAS at a given offset.
`default boolean`	`compareAndSwapFloat(long offset, float expected, float value)` Perform a 32-bit float CAS at a given offset.
`boolean`	`compareAndSwapInt(long offset, int expected, int value)` Perform a 32-bit CAS at a given offset.
`boolean`	`compareAndSwapLong(long offset, long expected, long value)` Perform a 64-bit CAS at a given offset.
`boolean`	`equals(Object obj)`
`boolean`	`equalsBytes(Bytes b2, long remaining)`
`int`	`hashCode()`
`int`	`lastDecimalPlaces()`
`void`	`lastDecimalPlaces(int lastDecimalPlaces)` Store the last number of decimal places.
`void`	`nativeRead(long address, long size)` This is an expert level method for copying raw native memory in bulk.
`void`	`nativeRead(long position, long address, long size)` expert level method for copying data to native memory.
`void`	`nativeWrite(long address, long size)` This is an expert level method for writing out data to native memory.
`void`	`nativeWrite(long address, long position, long size)` expert level method to copy data from native memory into the BytesStore
`default void`	`parse8bit(Appendable buffer, StopCharsTester stopCharsTester)` parse text with ISO-8859-1 decoding as character terminated.
`default void`	`parse8bit(Appendable buffer, StopCharTester stopCharTester)` parse text with ISO-8859-1 decoding as character terminated.
`default Boolean`	`parseBoolean(StopCharTester tester)` Return true or false, or null if it could not be detected as true or false.
`default double`	`parseDouble()` parse text as a double decimal.
`default long`	`parseLong()` parse text as a long integer.
`default long`	`parseLongDecimal()` Parse the significant digits of a decimal number.
`default void`	`parseUTF(Appendable buffer, StopCharsTester stopCharsTester)` Deprecated.
`default void`	`parseUTF(Appendable buffer, StopCharTester stopCharTester)` Deprecated.
`default String`	`parseUTF(StopCharTester stopCharTester)` Deprecated.
`default void`	`parseUtf8(Appendable buffer, StopCharsTester stopCharsTester)` parse text with UTF-8 decoding as one or two character terminated.
`default void`	`parseUtf8(Appendable buffer, StopCharTester stopCharTester)` parse text with UTF-8 decoding as character terminated.
`default String`	`parseUtf8(StopCharTester stopCharTester)` parse text with UTF-8 decoding as character terminated.
`int`	`peekUnsignedByte()`
`Bytes<Underlying>`	`prewrite(byte[] bytes)` Write backward in binary a byte
`Bytes<Underlying>`	`prewriteByte(byte i8)` Write backward in binary a byte
`Bytes<Underlying>`	`prewriteInt(int i)` Write backward in binary a 4 byte int
`Bytes<Underlying>`	`prewriteLong(long l)` Write backward in binary an 8 byte long
`protected long`	`prewriteOffsetPositionMoved(long subtracting)`
`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 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()`
`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()
`Bytes<Underlying>`	`readPosition(long position)`
`default long`	`readRemaining()`
`short`	`readShort()`
`short`	`readShort(long offset)` Read a short at an offset
`Bytes<Underlying>`	`readSkip(long bytesToSkip)` Skip a number of bytes by moving the readPosition.
`int`	`readUnsignedByte()`
`int`	`readVolatileInt()`
`long`	`readVolatileLong()`
`long`	`realCapacity()`
`long`	`refCount()`
`void`	`release()`
`void`	`reserve()`
`default boolean`	`skipTo(StopCharTester tester)` Skip text until a terminating character is reached.
`long`	`start()`
`String`	`toString()`
`Underlying`	`underlyingObject()`
`Bytes<Underlying>`	`write(byte[] bytes, int offset, int length)`
`Bytes<Underlying>`	`write(ByteBuffer buffer)`
`Bytes<Underlying>`	`write(long offsetInRDO, byte[] bytes, int offset, int length)`
`void`	`write(long offsetInRDO, ByteBuffer bytes, int offset, int length)`
`Bytes<Underlying>`	`write(long offsetInRDO, RandomDataInput bytes, long offset, long length)`
`Bytes<Underlying>`	`writeByte(byte i8)`
`Bytes<Underlying>`	`writeByte(long offset, byte i)` Write an unsigned byte at an offset.
`Bytes<Underlying>`	`writeDouble(double d)`
`Bytes<Underlying>`	`writeDouble(long offset, double d)` Write a double at an offset.
`Bytes<Underlying>`	`writeFloat(float f)`
`Bytes<Underlying>`	`writeFloat(long offset, float d)` Write a float at an offset.
`Bytes<Underlying>`	`writeInt(int i)`
`Bytes<Underlying>`	`writeInt(long offset, int i)` Write an int at an offset.
`long`	`writeLimit()`
`Bytes<Underlying>`	`writeLimit(long limit)`
`Bytes<Underlying>`	`writeLong(long i64)`
`Bytes<Underlying>`	`writeLong(long offset, long i)` Write a long at an offset.
`protected long`	`writeOffsetPositionMoved(long adding)`
`Bytes<Underlying>`	`writeOrderedInt(int i)`
`Bytes<Underlying>`	`writeOrderedInt(long offset, int i)` Perform a non stalling write with a store barrier.
`Bytes<Underlying>`	`writeOrderedLong(long i)`
`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()
`Bytes<Underlying>`	`writePosition(long position)`
`default long`	`writeRemaining()`
`Bytes<Underlying>`	`writeShort(long offset, short i)` Write a short at an offset.
`Bytes<Underlying>`	`writeShort(short i16)`
`Bytes<Underlying>`	`writeSkip(long bytesToSkip)` Skip a number of bytes by moving the readPosition.
`Bytes<Underlying>`	`writeVolatileByte(long offset, byte i8)`
`Bytes<Underlying>`	`writeVolatileInt(long offset, int i32)`
`Bytes<Underlying>`	`writeVolatileLong(long offset, long i64)`
`Bytes<Underlying>`	`writeVolatileShort(long offset, short i16)`

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, bytesForRead, copy, elasticByteBuffer, elasticByteBuffer, empty, ensureCapacity, expect, expect, from, fromHexString, isClear, isElastic, isEqual, safeLimit, toHexString, toHexString, toHexString, toString, toString, toString, unchecked, wrapForRead, wrapForRead, wrapForRead, wrapForWrite, wrapForWrite

Methods inherited from interface net.openhft.chronicle.bytes.BytesStore
addAndGetByteNotAtomic, addAndGetDoubleNotAtomic, addAndGetFloatNotAtomic, addAndGetIntNotAtomic, addAndGetLongNotAtomic, addAndGetShortNotAtomic, addAndGetUnsignedByteNotAtomic, addAndGetUnsignedIntNotAtomic, addAndGetUnsignedShortNotAtomic, byteCheckSum, bytesForWrite, charAt, contentEquals, copyTo, copyTo, endsWith, equalBytes, inside, length, longCheckSum, nativePointer, startsWith, subSequence, to8bitString, toDebugString, toDebugString, wrap, wrap, wrap, wrap, zeroOut

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

Methods inherited from interface net.openhft.chronicle.bytes.RandomDataOutput
append, write, write, writeBoolean, writeByte, 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.StreamingDataInput
inputStream, parseHexLong, parseUTF, parseUtf8, parseWithLength, read, read, read, read, read8bit, read8bit, read8bit, read8bit, readBoolean, readEnum, readStopBit, readStopBitDouble, readUnsignedInt, readUnsignedShort, readUtf8, readUtf8, readUTFΔ, readUTFΔ, readWithLength

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

Methods inherited from interface net.openhft.chronicle.bytes.StreamingDataOutput
appendUtf8, appendUtf8, appendUtf8, appendUtf8, copyFrom, outputStream, write, write, write, write, write, write8bit, write8bit, write8bit, write8bit, writeBoolean, writeEnum, writeStopBit, writeStopBit, writeUnsignedByte, writeUnsignedInt, writeUnsignedShort, writeUtf8, writeUTFΔ

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

Methods inherited from interface net.openhft.chronicle.core.io.Closeable
closeQuietly, notifyClosing

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

- Field Detail
  - bytesStore
```
@Nullable
protected BytesStore<Bytes<Underlying>,Underlying> bytesStore
```
  - readPosition
```
protected long readPosition
```
  - writePosition
```
protected long writePosition
```
  - writeLimit
```
protected long writeLimit
```
- Method Detail
  - clear
```
@NotNull
public Bytes<Underlying> clear()
```
    Set the readPosition= writePosition = start, writeLimit = capacity
    
    Returns:
    
    this
  - clearAndPad
```
public 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()
```
    Specified by:
    
    realCapacity in interface Bytes<Underlying>
    
    Specified by:
    
    realCapacity in interface BytesStore<Bytes<Underlying>,Underlying>
    
    Specified by:
    
    realCapacity in interface RandomDataInput
    
    Returns:
    
    if isElastic, this can be much lower than the virtual capacity().
  - 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,
                                 IllegalArgumentException,
                                 net.openhft.chronicle.core.io.IORuntimeException
```
    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
    
    IllegalArgumentException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - compareAndSwapLong
```
public boolean compareAndSwapLong(long offset,
                                  long expected,
                                  long value)
                           throws BufferOverflowException,
                                  IllegalArgumentException,
                                  net.openhft.chronicle.core.io.IORuntimeException
```
    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
    
    IllegalArgumentException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - readPosition
```
public Bytes<Underlying> readPosition(long position)
                               throws BufferUnderflowException
```
    Specified by:
    
    readPosition in interface StreamingDataInput<Bytes<Underlying>>
    
    Throws:
    
    BufferUnderflowException
  - readLimit
```
public Bytes<Underlying> readLimit(long limit)
                            throws BufferUnderflowException
```
    Specified by:
    
    readLimit in interface StreamingDataInput<Bytes<Underlying>>
    
    Throws:
    
    BufferUnderflowException
  - writePosition
```
public Bytes<Underlying> writePosition(long position)
                                throws BufferOverflowException
```
    Specified by:
    
    writePosition in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
  - readSkip
```
public Bytes<Underlying> readSkip(long bytesToSkip)
                           throws BufferUnderflowException,
                                  net.openhft.chronicle.core.io.IORuntimeException
```
    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
    
    IORuntimeException - if an error occurred trying to obtain the data.
    
    net.openhft.chronicle.core.io.IORuntimeException
  - writeSkip
```
public Bytes<Underlying> writeSkip(long bytesToSkip)
                            throws BufferOverflowException,
                                   net.openhft.chronicle.core.io.IORuntimeException
```
    Description copied from interface: StreamingDataOutput
    
    Skip a number of bytes by moving the readPosition. Must be less than or equal to the readLimit.
    
    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
    
    IORuntimeException - if an error occurred trying to obtain the data.
    
    net.openhft.chronicle.core.io.IORuntimeException
  - writeLimit
```
public Bytes<Underlying> writeLimit(long limit)
                             throws BufferOverflowException
```
    Specified by:
    
    writeLimit in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
  - readUnsignedByte
```
public int readUnsignedByte()
                     throws net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    readUnsignedByte in interface StreamingDataInput<Bytes<Underlying>>
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException
  - readByte
```
public byte readByte()
              throws net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    readByte in interface StreamingDataInput<Bytes<Underlying>>
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException
  - peekUnsignedByte
```
public int peekUnsignedByte()
                     throws net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    peekUnsignedByte in interface StreamingDataInput<Bytes<Underlying>>
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException
  - readShort
```
public short readShort()
                throws BufferUnderflowException,
                       net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    readShort in interface StreamingDataInput<Bytes<Underlying>>
    
    Throws:
    
    BufferUnderflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - readInt
```
public int readInt()
            throws BufferUnderflowException,
                   net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    readInt in interface StreamingDataInput<Bytes<Underlying>>
    
    Throws:
    
    BufferUnderflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - readLong
```
public long readLong()
              throws BufferUnderflowException,
                     net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    readLong in interface StreamingDataInput<Bytes<Underlying>>
    
    Throws:
    
    BufferUnderflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - readFloat
```
public float readFloat()
                throws BufferUnderflowException,
                       net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    readFloat in interface StreamingDataInput<Bytes<Underlying>>
    
    Throws:
    
    BufferUnderflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - readDouble
```
public double readDouble()
                  throws BufferUnderflowException,
                         net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    readDouble in interface StreamingDataInput<Bytes<Underlying>>
    
    Throws:
    
    BufferUnderflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - readVolatileInt
```
public int readVolatileInt()
                    throws BufferUnderflowException,
                           net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    readVolatileInt in interface StreamingDataInput<Bytes<Underlying>>
    
    Throws:
    
    BufferUnderflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - readVolatileLong
```
public long readVolatileLong()
                      throws BufferUnderflowException,
                             net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    readVolatileLong in interface StreamingDataInput<Bytes<Underlying>>
    
    Throws:
    
    BufferUnderflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - readOffsetPositionMoved
```
protected long readOffsetPositionMoved(long adding)
                                throws BufferUnderflowException,
                                       net.openhft.chronicle.core.io.IORuntimeException
```
    Throws:
    
    BufferUnderflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - reserve
```
public void reserve()
             throws IllegalStateException
```
    Specified by:
    
    reserve in interface net.openhft.chronicle.core.ReferenceCounted
    
    Throws:
    
    IllegalStateException
  - release
```
public void release()
             throws IllegalStateException
```
    Specified by:
    
    release in interface net.openhft.chronicle.core.ReferenceCounted
    
    Throws:
    
    IllegalStateException
  - refCount
```
public long refCount()
```
    Specified by:
    
    refCount in interface net.openhft.chronicle.core.ReferenceCounted
  - writeByte
```
@NotNull
public Bytes<Underlying> writeByte(long offset,
                                            byte i)
                                     throws BufferOverflowException,
                                            IllegalArgumentException,
                                            net.openhft.chronicle.core.io.IORuntimeException
```
    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
    
    IORuntimeException - if the underlying buffer fails to resize.
    
    IllegalArgumentException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - writeShort
```
@NotNull
public Bytes<Underlying> writeShort(long offset,
                                             short i)
                                      throws BufferOverflowException,
                                             IllegalArgumentException,
                                             net.openhft.chronicle.core.io.IORuntimeException
```
    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
    
    IORuntimeException - if the underlying buffer fails to resize.
    
    IllegalArgumentException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - writeInt
```
@NotNull
public Bytes<Underlying> writeInt(long offset,
                                           int i)
                                    throws BufferOverflowException,
                                           IllegalArgumentException,
                                           net.openhft.chronicle.core.io.IORuntimeException
```
    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
    
    IORuntimeException - if the underlying buffer fails to resize.
    
    IllegalArgumentException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - writeOrderedInt
```
@NotNull
public Bytes<Underlying> writeOrderedInt(long offset,
                                                  int i)
                                           throws BufferOverflowException,
                                                  IllegalArgumentException,
                                                  net.openhft.chronicle.core.io.IORuntimeException
```
    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
    
    IORuntimeException - if the underlying buffer fails to resize.
    
    IllegalArgumentException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - writeLong
```
@NotNull
public Bytes<Underlying> writeLong(long offset,
                                            long i)
                                     throws BufferOverflowException,
                                            IllegalArgumentException,
                                            net.openhft.chronicle.core.io.IORuntimeException
```
    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
    
    IORuntimeException - if the underlying buffer fails to resize.
    
    IllegalArgumentException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - writeOrderedLong
```
@NotNull
public Bytes<Underlying> writeOrderedLong(long offset,
                                                   long i)
                                            throws BufferOverflowException,
                                                   IllegalArgumentException,
                                                   net.openhft.chronicle.core.io.IORuntimeException
```
    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
    
    IllegalArgumentException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - writeFloat
```
@NotNull
public Bytes<Underlying> writeFloat(long offset,
                                             float d)
                                      throws BufferOverflowException,
                                             IllegalArgumentException,
                                             net.openhft.chronicle.core.io.IORuntimeException
```
    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
    
    IORuntimeException - if the underlying buffer fails to resize.
    
    IllegalArgumentException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - writeDouble
```
@NotNull
public Bytes<Underlying> writeDouble(long offset,
                                              double d)
                                       throws BufferOverflowException,
                                              IllegalArgumentException,
                                              net.openhft.chronicle.core.io.IORuntimeException
```
    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
    
    IORuntimeException - if the underlying buffer fails to resize.
    
    IllegalArgumentException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - writeVolatileByte
```
public Bytes<Underlying> writeVolatileByte(long offset,
                                           byte i8)
                                    throws BufferOverflowException,
                                           IllegalArgumentException,
                                           net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    writeVolatileByte in interface RandomDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    IllegalArgumentException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - writeVolatileShort
```
public Bytes<Underlying> writeVolatileShort(long offset,
                                            short i16)
                                     throws BufferOverflowException,
                                            IllegalArgumentException,
                                            net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    writeVolatileShort in interface RandomDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    IllegalArgumentException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - writeVolatileInt
```
public Bytes<Underlying> writeVolatileInt(long offset,
                                          int i32)
                                   throws BufferOverflowException,
                                          IllegalArgumentException,
                                          net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    writeVolatileInt in interface RandomDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    IllegalArgumentException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - writeVolatileLong
```
public Bytes<Underlying> writeVolatileLong(long offset,
                                           long i64)
                                    throws BufferOverflowException,
                                           IllegalArgumentException,
                                           net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    writeVolatileLong in interface RandomDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    IllegalArgumentException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - write
```
@NotNull
public Bytes<Underlying> write(long offsetInRDO,
                                        byte[] bytes,
                                        int offset,
                                        int length)
                                 throws BufferOverflowException,
                                        IllegalArgumentException,
                                        net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    write in interface RandomDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    IllegalArgumentException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - write
```
public void write(long offsetInRDO,
                  ByteBuffer bytes,
                  int offset,
                  int length)
           throws BufferOverflowException,
                  IllegalArgumentException,
                  net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    write in interface RandomDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    IllegalArgumentException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - write
```
@NotNull
public Bytes<Underlying> write(long offsetInRDO,
                                        RandomDataInput bytes,
                                        long offset,
                                        long length)
                                 throws BufferOverflowException,
                                        BufferUnderflowException,
                                        IllegalArgumentException,
                                        net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    write in interface RandomDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    BufferUnderflowException
    
    IllegalArgumentException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - readByte
```
public byte readByte(long offset)
              throws BufferUnderflowException,
                     net.openhft.chronicle.core.io.IORuntimeException
```
    Description copied from interface: RandomDataInput
    
    Read byte at an offset
    
    Specified by:
    
    readByte in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the byte
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
    
    IORuntimeException - if an error occurred trying to obtain the data.
    
    net.openhft.chronicle.core.io.IORuntimeException
  - readShort
```
public short readShort(long offset)
                throws BufferUnderflowException,
                       net.openhft.chronicle.core.io.IORuntimeException
```
    Description copied from interface: RandomDataInput
    
    Read a short at an offset
    
    Specified by:
    
    readShort in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the short
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
    
    IORuntimeException - if an error occurred trying to obtain the data.
    
    net.openhft.chronicle.core.io.IORuntimeException
  - readInt
```
public int readInt(long offset)
            throws BufferUnderflowException,
                   net.openhft.chronicle.core.io.IORuntimeException
```
    Description copied from interface: RandomDataInput
    
    Read an int at an offset
    
    Specified by:
    
    readInt in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the int
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
    
    IORuntimeException - if an error occurred trying to obtain the data.
    
    net.openhft.chronicle.core.io.IORuntimeException
  - readLong
```
public long readLong(long offset)
              throws BufferUnderflowException,
                     net.openhft.chronicle.core.io.IORuntimeException
```
    Description copied from interface: RandomDataInput
    
    Read a long at an offset
    
    Specified by:
    
    readLong in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the long
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
    
    IORuntimeException - if an error occurred trying to obtain the data.
    
    net.openhft.chronicle.core.io.IORuntimeException
  - readFloat
```
public float readFloat(long offset)
                throws BufferUnderflowException,
                       net.openhft.chronicle.core.io.IORuntimeException
```
    Description copied from interface: RandomDataInput
    
    Read a float at an offset
    
    Specified by:
    
    readFloat in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the float
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
    
    IORuntimeException - if an error occurred trying to obtain the data.
    
    net.openhft.chronicle.core.io.IORuntimeException
  - readDouble
```
public double readDouble(long offset)
                  throws BufferUnderflowException,
                         net.openhft.chronicle.core.io.IORuntimeException
```
    Description copied from interface: RandomDataInput
    
    Read a double at an offset
    
    Specified by:
    
    readDouble in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the double
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
    
    IORuntimeException - if an error occurred trying to obtain the data.
    
    net.openhft.chronicle.core.io.IORuntimeException
  - writeByte
```
@NotNull
public Bytes<Underlying> writeByte(byte i8)
                                     throws BufferOverflowException,
                                            net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    writeByte in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - prewrite
```
public Bytes<Underlying> prewrite(byte[] bytes)
```
    Description copied from interface: BytesPrepender
    
    Write backward in binary a byte
    Note: it moves the readPosition not the writePosition / readLimit
    
    Specified by:
    
    prewrite in interface BytesPrepender<Bytes<Underlying>>
    
    Parameters:
    
    bytes - to prepend to.
  - prewriteByte
```
@NotNull
public Bytes<Underlying> prewriteByte(byte i8)
                                        throws BufferOverflowException,
                                               net.openhft.chronicle.core.io.IORuntimeException
```
    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.
    
    Throws:
    
    BufferOverflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - prewriteInt
```
public Bytes<Underlying> prewriteInt(int i)
```
    Description copied from interface: BytesPrepender
    
    Write backward in binary a 4 byte int
    Note: it moves the readPosition not the writePosition / readLimit
    
    Specified by:
    
    prewriteInt in interface BytesPrepender<Bytes<Underlying>>
    
    Parameters:
    
    i - integer to prepend to.
  - prewriteShort
```
public Bytes<Underlying> prewriteShort(short i)
```
    Description copied from interface: BytesPrepender
    
    Write backward in binary a 2 byte int
    Note: it moves the readPosition not the writePosition / readLimit
    
    Specified by:
    
    prewriteShort in interface BytesPrepender<Bytes<Underlying>>
    
    Parameters:
    
    i - short to prepend to.
  - prewriteLong
```
public Bytes<Underlying> prewriteLong(long l)
```
    Description copied from interface: BytesPrepender
    
    Write backward in binary an 8 byte long
    Note: it moves the readPosition not the writePosition / readLimit
    
    Specified by:
    
    prewriteLong in interface BytesPrepender<Bytes<Underlying>>
    
    Parameters:
    
    l - long to prepend to.
  - writeOffsetPositionMoved
```
protected long writeOffsetPositionMoved(long adding)
                                 throws BufferOverflowException,
                                        net.openhft.chronicle.core.io.IORuntimeException
```
    Throws:
    
    BufferOverflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - prewriteOffsetPositionMoved
```
protected long prewriteOffsetPositionMoved(long subtracting)
                                    throws BufferOverflowException,
                                           net.openhft.chronicle.core.io.IORuntimeException
```
    Throws:
    
    BufferOverflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - writeShort
```
@NotNull
public Bytes<Underlying> writeShort(short i16)
                                      throws BufferOverflowException,
                                             net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    writeShort in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - writeInt
```
@NotNull
public Bytes<Underlying> writeInt(int i)
                                    throws BufferOverflowException,
                                           net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    writeInt in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - writeLong
```
@NotNull
public Bytes<Underlying> writeLong(long i64)
                                     throws BufferOverflowException,
                                            net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    writeLong in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - writeFloat
```
@NotNull
public Bytes<Underlying> writeFloat(float f)
                                      throws BufferOverflowException,
                                             net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    writeFloat in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - writeDouble
```
@NotNull
public Bytes<Underlying> writeDouble(double d)
                                       throws BufferOverflowException,
                                              net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    writeDouble in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - write
```
@NotNull
public Bytes<Underlying> write(byte[] bytes,
                                        int offset,
                                        int length)
                                 throws BufferOverflowException,
                                        IllegalArgumentException,
                                        net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    write in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    IllegalArgumentException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - write
```
@NotNull
public Bytes<Underlying> write(@NotNull
                                        ByteBuffer buffer)
                                 throws BufferOverflowException,
                                        net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    write in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - writeOrderedInt
```
@NotNull
public Bytes<Underlying> writeOrderedInt(int i)
                                           throws BufferOverflowException,
                                                  net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    writeOrderedInt in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - writeOrderedLong
```
@NotNull
public Bytes<Underlying> writeOrderedLong(long i)
                                            throws BufferOverflowException,
                                                   net.openhft.chronicle.core.io.IORuntimeException
```
    Specified by:
    
    writeOrderedLong in interface StreamingDataOutput<Bytes<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - address
```
public long address(long offset)
             throws BufferOverflowException,
                    BufferUnderflowException
```
    Obtain the underlying address. This is for expert users only.
    
    Parameters:
    
    offset - within this buffer. address(start()) is the actual address of the first byte.
    
    Returns:
    
    the underlying address of the buffer
    
    Throws:
    
    BufferOverflowException
    
    BufferUnderflowException
  - 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
                           Bytes b2,
                           long remaining)
                    throws net.openhft.chronicle.core.io.IORuntimeException
```
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException
  - toString
```
@NotNull
public String toString()
```
    Specified by:
    
    toString in interface CharSequence
    
    Overrides:
    
    toString in class Object
  - nativeRead
```
public void nativeRead(long address,
                       long size)
                throws BufferUnderflowException,
                       net.openhft.chronicle.core.io.IORuntimeException
```
    Description copied from interface: StreamingDataInput
    
    This is an expert level method for copying raw native memory in bulk.
    
    Specified by:
    
    nativeRead in interface StreamingDataInput<Bytes<Underlying>>
    
    Parameters:
    
    address - of the memory.
    
    size - in bytes.
    
    Throws:
    
    BufferUnderflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - nativeWrite
```
public void nativeWrite(long address,
                        long size)
                 throws BufferOverflowException,
                        net.openhft.chronicle.core.io.IORuntimeException
```
    Description copied from interface: StreamingDataOutput
    
    This is an expert level method for writing out data to native memory.
    
    Specified by:
    
    nativeWrite in interface StreamingDataOutput<Bytes<Underlying>>
    
    Parameters:
    
    address - to write to.
    
    size - in bytes.
    
    Throws:
    
    BufferOverflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - nativeRead
```
public void nativeRead(long position,
                       long address,
                       long size)
```
    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
  - nativeWrite
```
public void nativeWrite(long address,
                        long position,
                        long size)
```
    Description copied from interface: RandomDataOutput
    
    expert level method to copy data from native memory into the BytesStore
    
    Specified by:
    
    nativeWrite in interface RandomDataOutput<Bytes<Underlying>>
    
    Parameters:
    
    address - in native memory to copy from
    
    position - in BytesStore to copy to
    
    size - in bytes
  - bytesStore
```
@Nullable
public BytesStore bytesStore()
```
    Specified by:
    
    bytesStore in interface Bytes<Underlying>
    
    Specified by:
    
    bytesStore in interface BytesStore<Bytes<Underlying>,Underlying>
    
    Returns:
    
    the ByteStore this Bytes wraps.
  - lastDecimalPlaces
```
public int lastDecimalPlaces()
```
    Returns:
    
    the last number of decimal places for parseDouble or parseLongDecimal
  - lastDecimalPlaces
```
public void lastDecimalPlaces(int lastDecimalPlaces)
```
    Store the last number of decimal places. If
    
    Parameters:
    
    lastDecimalPlaces - set the number of decimal places if positive, otherwise 0.
  - reader
```
public Reader reader()
```
    Access these bytes as an ISO-8859-1 encoded Reader
    
    Returns:
    
    as a Reader
  - parseBoolean
```
public Boolean parseBoolean(@NotNull
                            StopCharTester tester)
```
    Return true or false, or null if it could not be detected as true or false. Case is not important
    
    false: f, false, n, no, 0
    
    true: t, true, y, yes, 1
    
    Parameters:
    
    tester - to detect the end of the text.
    
    Returns:
    
    true, false, or null if neither.
  - parseUtf8
```
@NotNull
public String parseUtf8(@NotNull
                                 StopCharTester stopCharTester)
```
    parse text with UTF-8 decoding as character terminated.
    
    Parameters:
    
    stopCharTester - to check if the end has been reached.
    
    Returns:
    
    the text as a String.
  - parseUTF
```
@Deprecated
public String parseUTF(@NotNull
                                   StopCharTester stopCharTester)
```
    Deprecated.
  - parseUtf8
```
public void parseUtf8(@NotNull
                      Appendable buffer,
                      @NotNull
                      StopCharTester stopCharTester)
```
    parse text with UTF-8 decoding as character terminated.
    
    Parameters:
    
    buffer - to populate
    
    stopCharTester - to check if the end has been reached.
  - parseUTF
```
@Deprecated
public void parseUTF(@NotNull
                                 Appendable buffer,
                                 @NotNull
                                 StopCharTester stopCharTester)
```
    Deprecated.
  - parseUtf8
```
public void parseUtf8(@NotNull
                      Appendable buffer,
                      @NotNull
                      StopCharsTester stopCharsTester)
               throws BufferUnderflowException,
                      BufferOverflowException,
                      net.openhft.chronicle.core.io.IORuntimeException
```
    parse text with UTF-8 decoding as one or two character terminated.
    
    Parameters:
    
    buffer - to populate
    
    stopCharsTester - to check if the end has been reached.
    
    Throws:
    
    BufferUnderflowException
    
    BufferOverflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - parseUTF
```
@Deprecated
public void parseUTF(@NotNull
                                 Appendable buffer,
                                 @NotNull
                                 StopCharsTester stopCharsTester)
                          throws BufferUnderflowException,
                                 BufferOverflowException,
                                 net.openhft.chronicle.core.io.IORuntimeException
```
    Deprecated.
    
    Throws:
    
    BufferUnderflowException
    
    BufferOverflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - parse8bit
```
public void parse8bit(Appendable buffer,
                      @NotNull
                      StopCharTester stopCharTester)
               throws BufferUnderflowException,
                      BufferOverflowException,
                      net.openhft.chronicle.core.io.IORuntimeException
```
    parse text with ISO-8859-1 decoding as character terminated.
    
    Parameters:
    
    buffer - to populate
    
    stopCharTester - to check if the end has been reached.
    
    Throws:
    
    BufferUnderflowException
    
    BufferOverflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - parse8bit
```
public void parse8bit(Appendable buffer,
                      @NotNull
                      StopCharsTester stopCharsTester)
               throws BufferUnderflowException,
                      BufferOverflowException,
                      net.openhft.chronicle.core.io.IORuntimeException
```
    parse text with ISO-8859-1 decoding as character terminated.
    
    Parameters:
    
    buffer - to populate
    
    stopCharsTester - to check if the end has been reached.
    
    Throws:
    
    BufferUnderflowException
    
    BufferOverflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - parseLong
```
public long parseLong()
               throws BufferUnderflowException,
                      net.openhft.chronicle.core.io.IORuntimeException
```
    parse text as a long integer. The terminating character is consumed.
    
    Returns:
    
    a long.
    
    Throws:
    
    BufferUnderflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - parseDouble
```
public double parseDouble()
                   throws BufferUnderflowException,
                          net.openhft.chronicle.core.io.IORuntimeException
```
    parse text as a double decimal. The terminating character is consumed.
    The number of decimal places can be retrieved with lastDecimalPlaces()
    
    Returns:
    
    a double.
    
    Throws:
    
    BufferUnderflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - parseLongDecimal
```
public long parseLongDecimal()
                      throws BufferUnderflowException
```
    Parse the significant digits of a decimal number.
    The number of decimal places can be retrieved with lastDecimalPlaces()
    
    Returns:
    
    the significant digits
    
    Throws:
    
    BufferUnderflowException
  - skipTo
```
public boolean skipTo(@NotNull
                      StopCharTester tester)
               throws net.openhft.chronicle.core.io.IORuntimeException
```
    Skip text until a terminating character is reached.
    
    Parameters:
    
    tester - to stop at
    
    Returns:
    
    true if a terminating character was found, false if the end of the buffer was reached.
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException
  - readRemaining
```
public long readRemaining()
```
    Returns:
    
    How many more bytes can we read.
  - writeRemaining
```
public long writeRemaining()
```
    Returns:
    
    How many more bytes can we written.
  - byteOrder
```
public ByteOrder byteOrder()
```
  - compareAndSwapFloat
```
public boolean compareAndSwapFloat(long offset,
                                   float expected,
                                   float value)
                            throws BufferOverflowException,
                                   IllegalArgumentException,
                                   net.openhft.chronicle.core.io.IORuntimeException
```
    Perform a 32-bit float CAS at a given offset.
    
    Parameters:
    
    offset - to perform CAS
    
    expected - value
    
    value - to set
    
    Returns:
    
    true, if successful.
    
    Throws:
    
    BufferOverflowException
    
    IllegalArgumentException
    
    net.openhft.chronicle.core.io.IORuntimeException
  - compareAndSwapDouble
```
public boolean compareAndSwapDouble(long offset,
                                    double expected,
                                    double value)
                             throws BufferOverflowException,
                                    IllegalArgumentException,
                                    net.openhft.chronicle.core.io.IORuntimeException
```
    Perform a 64-bit double CAS at a given offset.
    
    Parameters:
    
    offset - to perform CAS
    
    expected - value
    
    value - to set
    
    Returns:
    
    true, if successful.
    
    Throws:
    
    BufferOverflowException
    
    IllegalArgumentException
    
    net.openhft.chronicle.core.io.IORuntimeException

Class AbstractBytes<Underlying>

Field Summary

Fields inherited from interface net.openhft.chronicle.bytes.Bytes

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

Method Summary

Methods inherited from class java.lang.Object

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

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

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

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

Methods inherited from interface java.lang.CharSequence

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

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

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

Methods inherited from interface net.openhft.chronicle.core.ReferenceCounted

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

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

Field Detail

bytesStore

readPosition

writePosition

writeLimit

Method Detail

clear

clearAndPad

readLimit

writeLimit

realCapacity

capacity

underlyingObject

start

readPosition

writePosition

compareAndSwapInt

compareAndSwapLong

readPosition

readLimit

writePosition

readSkip

writeSkip

writeLimit

readUnsignedByte

readByte

peekUnsignedByte

readShort

readInt

readLong

readFloat

readDouble

readVolatileInt

readVolatileLong

readOffsetPositionMoved

reserve

release

refCount

writeByte

writeShort

writeInt

writeOrderedInt

writeLong

writeOrderedLong

writeFloat

writeDouble

writeVolatileByte

writeVolatileShort

writeVolatileInt

writeVolatileLong

write

write

write

readByte

readShort

readInt

readLong

readFloat

readDouble

writeByte

prewrite

prewriteByte

prewriteInt