HeapBytesStore (OpenHFT/Chronicle-Bytes 1.16.29 API)

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

All Implemented Interfaces:

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

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

Constructor Summary

Constructors
Constructor and Description

HeapBytesStore()

Constructors
Constructor and Description
`HeapBytesStore()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Default Methods
Modifier and Type	Method and Description
`long`	`addressForRead(long offset)` Obtain the underlying addressForRead.
`default long`	`addressForRead(long offset, int buffer)`
`long`	`addressForWrite(long offset)` Obtain the underlying addressForRead.
`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)`
`boolean`	`isDirectMemory()`
`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
`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
`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()`
`boolean`	`sharedMemory()`
`void`	`testAndSetInt(long offset, int expected, int value)`
`String`	`toString()`
`boolean`	`tryReserve()`
`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 writeOffset, RandomDataInput bytes, long readOffset, 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 net.openhft.chronicle.bytes.AbstractBytesStore
hashCode, peekUnsignedByte, readPosition, readRemaining, start

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

Methods inherited from interface net.openhft.chronicle.bytes.BytesStore
addAndGetByteNotAtomic, addAndGetDoubleNotAtomic, addAndGetFloatNotAtomic, addAndGetIntNotAtomic, addAndGetLongNotAtomic, addAndGetShortNotAtomic, addAndGetUnsignedByteNotAtomic, addAndGetUnsignedIntNotAtomic, addAndGetUnsignedShortNotAtomic, byteCheckSum, byteCheckSum, bytesForRead, bytesForWrite, bytesStore, charAt, cipher, cipher, contentEquals, copyTo, copyTo, empty, endsWith, equalBytes, from, inside, inside, isClear, isEmpty, isPresent, isPresent, length, longCheckSum, nativePointer, readWrite, realCapacity, safeLimit, startsWith, startsWith, subSequence, to8bitString, toDebugString, toDebugString, wrap, writeMaxLong, zeroOut

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

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 net.openhft.chronicle.core.ReferenceCounted
release, releaseAll

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

Constructor Detail
- HeapBytesStore
```
public HeapBytesStore()
```

Method Detail

uninitialized

@NotNull
public static <T> HeapBytesStore<T> uninitialized()

isDirectMemory
```
public boolean isDirectMemory()
```
Returns:

whether it uses direct memory or not.

init

public void init(@NotNull
                 ByteBuffer byteBuffer)

init

public void init(@NotNull
                 byte[] byteArray)

uninit
```
public void uninit()
```

move

public void move(long from,
                 long to,
                 long length)

toString
```
@NotNull
public String toString()
```
Specified by:

toString in interface CharSequence

Overrides:

toString in class Object

copy

@NotNull
public BytesStore<HeapBytesStore<Underlying>,Underlying> copy()

Returns:: a copy of this BytesStore.

reserve
```
public void reserve()
```

release
```
public void release()
```

refCount
```
public long refCount()
```

tryReserve
```
public boolean tryReserve()
```

capacity
```
public long capacity()
```
Returns:

The maximum limit you can set.

underlyingObject
```
@NotNull
public Underlying underlyingObject()
```
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.

testAndSetInt

public void testAndSetInt(long offset,
                          int expected,
                          int value)

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

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

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

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

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

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

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.

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.

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.

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.

Parameters:

offset - to read

Returns:

the long value

Throws:

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