HeapBytesStore (OpenHFT/Chronicle-Bytes 2.20.61 API)

java.lang.Object
- net.openhft.chronicle.core.io.AbstractReferenceCounted
- - 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.io.ReferenceCounted, net.openhft.chronicle.core.io.ReferenceCountedTracer, net.openhft.chronicle.core.io.ReferenceOwner
```
public class HeapBytesStore<Underlying>
extends AbstractBytesStore<HeapBytesStore<Underlying>,Underlying>
```
Wrapper for Heap ByteBuffers and arrays.

Field Summary
- Fields inherited from class net.openhft.chronicle.core.io.AbstractReferenceCounted
  WARN_NS
- Fields inherited from interface net.openhft.chronicle.bytes.RandomDataInput
  charToString
- Fields inherited from interface net.openhft.chronicle.core.io.ReferenceOwner
  INIT

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.
`long`	`addressForWritePosition()`
`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.
`@NotNull BytesStore<HeapBytesStore<Underlying>,Underlying>`	`copy()`
`boolean`	`equals(Object obj)`
`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
`protected void`	`performRelease()`
`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.
`boolean`	`sharedMemory()`
`void`	`testAndSetInt(long offset, int expected, int value)`
`@NotNull String`	`toString()`
`Underlying`	`underlyingObject()`
`static @NotNull HeapBytesStore<byte[]>`	`wrap(@NotNull byte[] byteArray)` Wraps a byte[].
`static @NotNull HeapBytesStore<ByteBuffer>`	`wrap(@NotNull ByteBuffer bb)` Wraps a ByteBuffer which can be either on heap or off heap.
`@NotNull HeapBytesStore<Underlying>`	`write(long offsetInRDO, byte[] bytes, int offset, int length)`
`void`	`write(long offsetInRDO, @NotNull ByteBuffer bytes, int offset, int length)`
`@NotNull HeapBytesStore<Underlying>`	`write(long writeOffset, @NotNull RandomDataInput bytes, long readOffset, long length)`
`@NotNull HeapBytesStore<Underlying>`	`writeByte(long offset, byte b)` Write an unsigned byte at an offset.
`@NotNull HeapBytesStore<Underlying>`	`writeDouble(long offset, double d)` Write a double at an offset.
`@NotNull HeapBytesStore<Underlying>`	`writeFloat(long offset, float f)` Write a float at an offset.
`@NotNull HeapBytesStore<Underlying>`	`writeInt(long offset, int i32)` Write an int at an offset.
`default long`	`writeLimit()`
`@NotNull HeapBytesStore<Underlying>`	`writeLong(long offset, long i64)` Write a long at an offset.
`@NotNull HeapBytesStore<Underlying>`	`writeOrderedInt(long offset, int i32)` Perform a non stalling write with a store barrier.
`@NotNull 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()`
`@NotNull HeapBytesStore<Underlying>`	`writeShort(long offset, short i16)` Write a short at an offset.
`@NotNull HeapBytesStore<Underlying>`	`writeVolatileByte(long offset, byte i8)`
`@NotNull HeapBytesStore<Underlying>`	`writeVolatileInt(long offset, int i32)`
`@NotNull HeapBytesStore<Underlying>`	`writeVolatileLong(long offset, long i64)`
`@NotNull HeapBytesStore<Underlying>`	`writeVolatileShort(long offset, short i16)`

Methods inherited from class net.openhft.chronicle.bytes.AbstractBytesStore
hashCode, peekUnsignedByte, performReleaseInBackground, readPosition, readRemaining, start

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

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

Methods inherited from interface net.openhft.chronicle.bytes.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, canReadDirect, 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.io.ReferenceCounted
refCount, release, releaseLast, releaseLast, reserve, reservedBy, reserveTransfer, tryReserve

Methods inherited from interface net.openhft.chronicle.core.io.ReferenceOwner
referenceId, referenceName, temporary

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

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

Method Detail

wrap

@NotNull
public static @NotNull HeapBytesStore<byte[]> wrap(@NotNull
                                                            @NotNull byte[] byteArray)

Description copied from interface: BytesStore

Wraps a byte[]. This means there is one copy in memory.

Parameters:: byteArray - to wrap
Returns:: BytesStore

wrap

@NotNull
public static @NotNull HeapBytesStore<ByteBuffer> wrap(@NotNull
                                                                @NotNull ByteBuffer bb)

Description copied from interface: BytesStore

Wraps a ByteBuffer which can be either on heap or off heap.

Parameters:: bb - to wrap
Returns:: BytesStore

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

whether it uses direct memory or not.

move

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

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

toString in interface CharSequence

Overrides:

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

copy

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

Returns:: a copy of this BytesStore.

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

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

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