HeapBytesStore (OpenHFT/Chronicle-Bytes 1.1.13 API)

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

All Implemented Interfaces:

Closeable, AutoCloseable, CharSequence, BytesStore<HeapBytesStore<Underlying>,Underlying>, RandomDataInput, RandomDataOutput<HeapBytesStore<Underlying>>, net.openhft.chronicle.core.ReferenceCounted
```
public class HeapBytesStore<Underlying>
extends Object
implements BytesStore<HeapBytesStore<Underlying>,Underlying>
```
Wrapper for Heap ByteBuffers and arrays.

Field Summary
- Fields inherited from interface net.openhft.chronicle.bytes.RandomDataInput
  charToString

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Default Methods
Modifier and Type	Method and Description
`long`	`address(long offset)` Obtain the underlying address.
`default ByteOrder`	`byteOrder()`
`long`	`capacity()`
`default boolean`	`compareAndSwapDouble(long offset, double expected, double value)` Perform a 64-bit double CAS at a given offset.
`default boolean`	`compareAndSwapFloat(long offset, float expected, float value)` Perform a 32-bit float CAS at a given offset.
`boolean`	`compareAndSwapInt(long offset, int expected, int value)` Perform a 32-bit CAS at a given offset.
`boolean`	`compareAndSwapLong(long offset, long expected, long value)` Perform a 64-bit CAS at a given offset.
`BytesStore<HeapBytesStore<Underlying>,Underlying>`	`copy()`
`boolean`	`equals(Object obj)`
`void`	`init(byte[] byteArray)`
`void`	`init(ByteBuffer byteBuffer)`
`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
`byte`	`readByte(long offset)` Read byte at an offset
`double`	`readDouble(long offset)` Read a double at an offset
`float`	`readFloat(long offset)` Read a float at an offset
`int`	`readInt(long offset)` Read an int at an offset
`default long`	`readLimit()`
`long`	`readLong(long offset)` Read a long at an offset
`default long`	`readPosition()` The read position must be start() <= readPosition() && readPosition() <= readLimit() && readPosition < safeLimit()
`default long`	`readRemaining()`
`short`	`readShort(long offset)` Read a short at an offset
`byte`	`readVolatileByte(long offset)` Read a 8-bit byte from memory with a load barrier.
`int`	`readVolatileInt(long offset)` Read a 32-bit int from memory with a load barrier.
`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`	`refCount()`
`void`	`release()`
`void`	`reserve()`
`default long`	`start()`
`String`	`toString()`
`Underlying`	`underlyingObject()`
`void`	`uninit()`
`static <T> HeapBytesStore<T>`	`uninitialized()`
`HeapBytesStore<Underlying>`	`write(long offsetInRDO, byte[] bytes, int offset, int length)`
`void`	`write(long offsetInRDO, ByteBuffer bytes, int offset, int length)`
`HeapBytesStore<Underlying>`	`write(long offsetInRDO, RandomDataInput bytes, long offset, long length)`
`HeapBytesStore<Underlying>`	`writeByte(long offset, byte b)` Write an unsigned byte at an offset.
`HeapBytesStore<Underlying>`	`writeDouble(long offset, double d)` Write a double at an offset.
`HeapBytesStore<Underlying>`	`writeFloat(long offset, float f)` Write a float at an offset.
`HeapBytesStore<Underlying>`	`writeInt(long offset, int i32)` Write an int at an offset.
`default long`	`writeLimit()`
`HeapBytesStore<Underlying>`	`writeLong(long offset, long i64)` Write a long at an offset.
`HeapBytesStore<Underlying>`	`writeOrderedInt(long offset, int i32)` Perform a non stalling write with a store barrier.
`HeapBytesStore<Underlying>`	`writeOrderedLong(long offset, long i)` Perform a non stalling write with a store barrier.
`default long`	`writePosition()` The read position must be readPosition() <= writePosition() && writePosition() <= writeLimit()
`default long`	`writeRemaining()`
`HeapBytesStore<Underlying>`	`writeShort(long offset, short i16)` Write a short at an offset.
`HeapBytesStore<Underlying>`	`writeVolatileByte(long offset, byte i8)`
`HeapBytesStore<Underlying>`	`writeVolatileInt(long offset, int i32)`
`HeapBytesStore<Underlying>`	`writeVolatileLong(long offset, long i64)`
`HeapBytesStore<Underlying>`	`writeVolatileShort(long offset, short i16)`

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

Methods inherited from interface net.openhft.chronicle.bytes.BytesStore
addAndGetByteNotAtomic, addAndGetDoubleNotAtomic, addAndGetFloatNotAtomic, addAndGetIntNotAtomic, addAndGetLongNotAtomic, addAndGetShortNotAtomic, addAndGetUnsignedByteNotAtomic, addAndGetUnsignedIntNotAtomic, addAndGetUnsignedShortNotAtomic, byteCheckSum, bytesForRead, bytesForWrite, bytesStore, charAt, contentEquals, copyTo, copyTo, endsWith, equalBytes, from, inside, isClear, length, longCheckSum, nativePointer, realCapacity, safeLimit, startsWith, subSequence, to8bitString, toDebugString, toDebugString, 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, readVolatileDouble, readVolatileFloat, 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 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 java.lang.CharSequence
chars, codePoints

- Method Detail
  - init
```
public void init(@NotNull
                 ByteBuffer byteBuffer)
```
  - init
```
public void init(@NotNull
                 byte[] byteArray)
```
  - uninit
```
public void uninit()
```
  - uninitialized
```
public static <T> HeapBytesStore<T> uninitialized()
```
  - toString
```
@NotNull
public String toString()
```
    Specified by:
    
    toString in interface CharSequence
    
    Overrides:
    
    toString in class Object
  - copy
```
@NotNull
public BytesStore<HeapBytesStore<Underlying>,Underlying> copy()
```
    Specified by:
    
    copy in interface BytesStore<HeapBytesStore<Underlying>,Underlying>
    
    Returns:
    
    a copy of this BytesStore.
  - reserve
```
public void reserve()
```
    Specified by:
    
    reserve in interface net.openhft.chronicle.core.ReferenceCounted
  - release
```
public void release()
```
    Specified by:
    
    release in interface net.openhft.chronicle.core.ReferenceCounted
  - refCount
```
public long refCount()
```
    Specified by:
    
    refCount in interface net.openhft.chronicle.core.ReferenceCounted
  - capacity
```
public long capacity()
```
    Specified by:
    
    capacity in interface BytesStore<HeapBytesStore<Underlying>,Underlying>
    
    Returns:
    
    The maximum limit you can set.
  - underlyingObject
```
@NotNull
public Underlying underlyingObject()
```
    Specified by:
    
    underlyingObject in interface BytesStore<HeapBytesStore<Underlying>,Underlying>
    
    Returns:
    
    the underlying object being wrapped, if there is one, or null if not.
  - compareAndSwapInt
```
public boolean compareAndSwapInt(long offset,
                                 int expected,
                                 int value)
```
    Perform a 32-bit CAS at a given offset.
    
    Parameters:
    
    offset - to perform CAS
    
    expected - value
    
    value - to set
    
    Returns:
    
    true, if successful.
  - compareAndSwapLong
```
public boolean compareAndSwapLong(long offset,
                                  long expected,
                                  long value)
```
    Perform a 64-bit CAS at a given offset.
    
    Parameters:
    
    offset - to perform CAS
    
    expected - value
    
    value - to set
    
    Returns:
    
    true, if successful.
  - readByte
```
public byte readByte(long offset)
              throws BufferUnderflowException
```
    Description copied from interface: RandomDataInput
    
    Read byte at an offset
    
    Specified by:
    
    readByte in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the byte
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readShort
```
public short readShort(long offset)
                throws BufferUnderflowException
```
    Description copied from interface: RandomDataInput
    
    Read a short at an offset
    
    Specified by:
    
    readShort in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the short
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readInt
```
public int readInt(long offset)
            throws BufferUnderflowException
```
    Description copied from interface: RandomDataInput
    
    Read an int at an offset
    
    Specified by:
    
    readInt in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the int
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readLong
```
public long readLong(long offset)
              throws BufferUnderflowException
```
    Description copied from interface: RandomDataInput
    
    Read a long at an offset
    
    Specified by:
    
    readLong in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the long
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readFloat
```
public float readFloat(long offset)
                throws BufferUnderflowException
```
    Description copied from interface: RandomDataInput
    
    Read a float at an offset
    
    Specified by:
    
    readFloat in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the float
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readDouble
```
public double readDouble(long offset)
                  throws BufferUnderflowException
```
    Description copied from interface: RandomDataInput
    
    Read a double at an offset
    
    Specified by:
    
    readDouble in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the double
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readVolatileByte
```
public byte readVolatileByte(long offset)
                      throws BufferUnderflowException
```
    Description copied from interface: RandomDataInput
    
    Read a 8-bit byte from memory with a load barrier.
    
    Specified by:
    
    readVolatileByte in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the byte value
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readVolatileShort
```
public short readVolatileShort(long offset)
                        throws BufferUnderflowException
```
    Description copied from interface: RandomDataInput
    
    Read a 16-bit short from memory with a load barrier.
    
    Specified by:
    
    readVolatileShort in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the short value
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readVolatileInt
```
public int readVolatileInt(long offset)
                    throws BufferUnderflowException
```
    Description copied from interface: RandomDataInput
    
    Read a 32-bit int from memory with a load barrier.
    
    Specified by:
    
    readVolatileInt in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the int value
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readVolatileLong
```
public long readVolatileLong(long offset)
                      throws BufferUnderflowException
```
    Description copied from interface: RandomDataInput
    
    Read a 64-bit long from memory with a load barrier.
    
    Specified by:
    
    readVolatileLong in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the long value
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - writeByte
```
@NotNull
public HeapBytesStore<Underlying> writeByte(long offset,
                                                     byte b)
                                              throws BufferOverflowException
```
    Description copied from interface: RandomDataOutput
    
    Write an unsigned byte at an offset.
    
    Specified by:
    
    writeByte in interface RandomDataOutput<HeapBytesStore<Underlying>>
    
    Parameters:
    
    offset - to write to
    
    b - the value
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
  - writeShort
```
@NotNull
public HeapBytesStore<Underlying> writeShort(long offset,
                                                      short i16)
                                               throws BufferOverflowException
```
    Description copied from interface: RandomDataOutput
    
    Write a short at an offset.
    
    Specified by:
    
    writeShort in interface RandomDataOutput<HeapBytesStore<Underlying>>
    
    Parameters:
    
    offset - to write to
    
    i16 - the value
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
  - writeInt
```
@NotNull
public HeapBytesStore<Underlying> writeInt(long offset,
                                                    int i32)
                                             throws BufferOverflowException
```
    Description copied from interface: RandomDataOutput
    
    Write an int at an offset.
    
    Specified by:
    
    writeInt in interface RandomDataOutput<HeapBytesStore<Underlying>>
    
    Parameters:
    
    offset - to write to
    
    i32 - the value
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
  - writeOrderedInt
```
@NotNull
public HeapBytesStore<Underlying> writeOrderedInt(long offset,
                                                           int i32)
                                                    throws BufferOverflowException
```
    Description copied from interface: RandomDataOutput
    
    Perform a non stalling write with a store barrier.
    
    Specified by:
    
    writeOrderedInt in interface RandomDataOutput<HeapBytesStore<Underlying>>
    
    Parameters:
    
    offset - to write to
    
    i32 - value to write
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
  - writeLong
```
@NotNull
public HeapBytesStore<Underlying> writeLong(long offset,
                                                     long i64)
                                              throws BufferOverflowException
```
    Description copied from interface: RandomDataOutput
    
    Write a long at an offset.
    
    Specified by:
    
    writeLong in interface RandomDataOutput<HeapBytesStore<Underlying>>
    
    Parameters:
    
    offset - to write to
    
    i64 - the value
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
  - writeOrderedLong
```
@NotNull
public HeapBytesStore<Underlying> writeOrderedLong(long offset,
                                                            long i)
                                                     throws BufferOverflowException
```
    Description copied from interface: RandomDataOutput
    
    Perform a non stalling write with a store barrier.
    
    Specified by:
    
    writeOrderedLong in interface RandomDataOutput<HeapBytesStore<Underlying>>
    
    Parameters:
    
    offset - to write to
    
    i - value to write
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException
  - writeFloat
```
@NotNull
public HeapBytesStore<Underlying> writeFloat(long offset,
                                                      float f)
                                               throws BufferOverflowException
```
    Description copied from interface: RandomDataOutput
    
    Write a float at an offset.
    
    Specified by:
    
    writeFloat in interface RandomDataOutput<HeapBytesStore<Underlying>>
    
    Parameters:
    
    offset - to write to
    
    f - the value
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
  - writeDouble
```
@NotNull
public HeapBytesStore<Underlying> writeDouble(long offset,
                                                       double d)
                                                throws BufferOverflowException
```
    Description copied from interface: RandomDataOutput
    
    Write a double at an offset.
    
    Specified by:
    
    writeDouble in interface RandomDataOutput<HeapBytesStore<Underlying>>
    
    Parameters:
    
    offset - to write to
    
    d - the value
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
  - writeVolatileByte
```
public HeapBytesStore<Underlying> writeVolatileByte(long offset,
                                                    byte i8)
                                             throws BufferOverflowException
```
    Specified by:
    
    writeVolatileByte in interface RandomDataOutput<HeapBytesStore<Underlying>>
    
    Throws:
    
    BufferOverflowException
  - writeVolatileShort
```
public HeapBytesStore<Underlying> writeVolatileShort(long offset,
                                                     short i16)
                                              throws BufferOverflowException
```
    Specified by:
    
    writeVolatileShort in interface RandomDataOutput<HeapBytesStore<Underlying>>
    
    Throws:
    
    BufferOverflowException
  - writeVolatileInt
```
public HeapBytesStore<Underlying> writeVolatileInt(long offset,
                                                   int i32)
                                            throws BufferOverflowException
```
    Specified by:
    
    writeVolatileInt in interface RandomDataOutput<HeapBytesStore<Underlying>>
    
    Throws:
    
    BufferOverflowException
  - writeVolatileLong
```
public HeapBytesStore<Underlying> writeVolatileLong(long offset,
                                                    long i64)
                                             throws BufferOverflowException
```
    Specified by:
    
    writeVolatileLong in interface RandomDataOutput<HeapBytesStore<Underlying>>
    
    Throws:
    
    BufferOverflowException
  - write
```
@NotNull
public HeapBytesStore<Underlying> write(long offsetInRDO,
                                                 byte[] bytes,
                                                 int offset,
                                                 int length)
                                          throws BufferOverflowException
```
    Specified by:
    
    write in interface RandomDataOutput<HeapBytesStore<Underlying>>
    
    Throws:
    
    BufferOverflowException
  - write
```
public void write(long offsetInRDO,
                  @NotNull
                  ByteBuffer bytes,
                  int offset,
                  int length)
           throws BufferOverflowException
```
    Specified by:
    
    write in interface RandomDataOutput<HeapBytesStore<Underlying>>
    
    Throws:
    
    BufferOverflowException
  - write
```
@NotNull
public HeapBytesStore<Underlying> write(long offsetInRDO,
                                                 RandomDataInput bytes,
                                                 long offset,
                                                 long length)
```
    Specified by:
    
    write in interface RandomDataOutput<HeapBytesStore<Underlying>>
  - address
```
public long address(long offset)
             throws UnsupportedOperationException
```
    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:
    
    UnsupportedOperationException - if the underlying buffer is on the heap
  - 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<HeapBytesStore<Underlying>>
    
    Parameters:
    
    address - in native memory to copy from
    
    position - in BytesStore to copy to
    
    size - in bytes
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - 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.
  - readRemaining
```
public long readRemaining()
```
    Returns:
    
    How many more bytes can we read.
  - writeRemaining
```
public long writeRemaining()
```
    Returns:
    
    How many more bytes can we written.
  - readLimit
```
public long readLimit()
```
    Returns:
    
    the highest offset or position allowed for this buffer.
  - writeLimit
```
public long writeLimit()
```
  - 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 HeapBytesStore<Underlying>

Field Summary

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

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

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

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

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

Methods inherited from interface java.lang.CharSequence

Method Detail

init

init

uninit

uninitialized

toString

copy

reserve

release

refCount

capacity

underlyingObject

compareAndSwapInt

compareAndSwapLong

readByte

readShort

readInt

readLong

readFloat

readDouble

readVolatileByte

readVolatileShort

readVolatileInt

readVolatileLong

writeByte

writeShort

writeInt

writeOrderedInt

writeLong

writeOrderedLong

writeFloat

writeDouble

writeVolatileByte

writeVolatileShort

writeVolatileInt

writeVolatileLong

write

write

write

address

nativeRead

nativeWrite

equals

start

readPosition

writePosition

readRemaining

writeRemaining

readLimit

writeLimit

byteOrder

compareAndSwapFloat

compareAndSwapDouble