NativeBytesStore (OpenHFT/Chronicle-Bytes 2.19.4 API)

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

All Implemented Interfaces:

CharSequence, BytesStore<NativeBytesStore<Underlying>,Underlying>, RandomDataInput, RandomDataOutput<NativeBytesStore<Underlying>>, net.openhft.chronicle.core.ReferenceCounted

Direct Known Subclasses:

MappedBytesStore, PointerBytesStore
```
public class NativeBytesStore<Underlying>
extends AbstractBytesStore<NativeBytesStore<Underlying>,Underlying>
```

Field Summary

Fields
Modifier and Type	Field and Description
`protected long`	`address`
`protected long`	`maximumLimit`
`protected net.openhft.chronicle.core.Memory`	`memory`
`protected Throwable`	`releasedHere`

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

Constructor Summary

Constructors
Constructor and Description
`NativeBytesStore(long address, long maximumLimit)`
`NativeBytesStore(long address, long maximumLimit, @Nullable Runnable deallocator, boolean elastic)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`int`	`addAndGetInt(long offset, int adding)` Perform an atomic add and get operation for a 32-bit int
`long`	`addAndGetLong(long offset, long adding)` Perform an atomic add and get operation for a 64-bit long
`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()`
`long`	`appendUTF(long pos, char[] chars, int offset, int length)` Deprecated.
`long`	`appendUtf8(long pos, char[] chars, int offset, int length)`
`int`	`byteCheckSum()` Return the bytes sum of the readable bytes.
`int`	`byteCheckSum(long position, long limit)`
`default ByteOrder`	`byteOrder()`
`@NotNull VanillaBytes<Underlying>`	`bytesForWrite()`
`boolean`	`canReadDirect(long length)`
`long`	`capacity()`
`void`	`checkReleased()`
`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<NativeBytesStore<Underlying>,Underlying>`	`copy()`
`long`	`copyTo(@NotNull BytesStore store)` Copy the data to another BytesStore as long as there is space available in the destination store.
`long`	`copyToDirect(@NotNull BytesStore store)`
`static @NotNull NativeBytesStore<ByteBuffer>`	`elasticByteBuffer()`
`static @NotNull NativeBytesStore<ByteBuffer>`	`elasticByteBuffer(int size, long maxSize)`
`boolean`	`equals(Object obj)`
`int`	`fastHash(long offset, int length)`
`int`	`fencedRead(long offset)`
`static @NotNull NativeBytesStore`	`from(@NotNull byte[] bytes)`
`static @NotNull NativeBytesStore`	`from(@NotNull String text)`
`void`	`init(@NotNull ByteBuffer bb, boolean elastic)`
`boolean`	`isDirectMemory()`
`static @NotNull NativeBytesStore<Void>`	`lazyNativeBytesStoreWithFixedCapacity(long capacity)`
`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.
`static @NotNull NativeBytesStore<Void>`	`nativeStore(long capacity)` this is an elastic native store
`static @NotNull NativeBytesStore<Void>`	`nativeStoreWithFixedCapacity(long capacity)`
`void`	`nativeWrite(long address, long position, long size)` expert level method to copy data from native memory into the BytesStore
`int`	`peekUnsignedByte(long offset)` Read an unsigned byte at an offset, or -1
`long`	`read(long offsetInRDI, byte[] bytes, int offset, int length)`
`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
`long`	`readIncompleteLong(long offset)` Read a long which is zero padded (high bytes) if the available bytes is less than 8.
`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
`int`	`readUnsignedByte(long offset)` Read an unsigned byte at an offset
`byte`	`readVolatileByte(long offset)` Read a 8-bit byte from memory with a load barrier.
`int`	`readVolatileInt(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`	`realCapacity()` Returns the actual capacity that can be potentially read.
`long`	`refCount()`
`void`	`release()`
`void`	`reserve()`
`long`	`safeLimit()`
`void`	`setAddress(long address)`
`boolean`	`sharedMemory()`
`void`	`testAndSetInt(long offset, int expected, int value)`
`@NotNull String`	`toString()`
`@NotNull ByteBuffer`	`toTemporaryDirectByteBuffer()`
`protected long`	`translate(long offset)`
`boolean`	`tryReserve()`
`Underlying`	`underlyingObject()`
`void`	`uninit()`
`static <T> @NotNull NativeBytesStore<T>`	`uninitialized()`
`static @NotNull NativeBytesStore<ByteBuffer>`	`wrap(@NotNull ByteBuffer bb)` Wraps a ByteBuffer which can be either on heap or off heap.
`@NotNull NativeBytesStore<Underlying>`	`write(long offsetInRDO, byte[] bytes, int offset, int length)`
`void`	`write(long offsetInRDO, @NotNull ByteBuffer bytes, int offset, int length)`
`@NotNull NativeBytesStore<Underlying>`	`write(long writeOffset, @NotNull RandomDataInput bytes, long readOffset, long length)`
`void`	`write0(long offsetInRDO, @NotNull RandomDataInput bytes, long offset, long length)`
`@NotNull NativeBytesStore<Underlying>`	`writeByte(long offset, byte i8)` Write an unsigned byte at an offset.
`@NotNull NativeBytesStore<Underlying>`	`writeDouble(long offset, double d)` Write a double at an offset.
`@NotNull NativeBytesStore<Underlying>`	`writeFloat(long offset, float f)` Write a float at an offset.
`@NotNull NativeBytesStore<Underlying>`	`writeInt(long offset, int i32)` Write an int at an offset.
`default long`	`writeLimit()`
`@NotNull NativeBytesStore<Underlying>`	`writeLong(long offset, long i64)` Write a long at an offset.
`@NotNull NativeBytesStore<Underlying>`	`writeOrderedInt(long offset, int i)` Perform a non stalling write with a store barrier.
`@NotNull NativeBytesStore<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 NativeBytesStore<Underlying>`	`writeShort(long offset, short i16)` Write a short at an offset.
`@NotNull NativeBytesStore<Underlying>`	`writeVolatileByte(long offset, byte i8)`
`@NotNull NativeBytesStore<Underlying>`	`writeVolatileInt(long offset, int i32)`
`@NotNull NativeBytesStore<Underlying>`	`writeVolatileLong(long offset, long i64)`
`@NotNull NativeBytesStore<Underlying>`	`writeVolatileShort(long offset, short i16)`
`@NotNull NativeBytesStore<Underlying>`	`zeroOut(long start, long end)` Fill the BytesStore with zeros

Methods inherited from class net.openhft.chronicle.bytes.AbstractBytesStore
hashCode, 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, bytesForRead, bytesStore, charAt, checkRefCount, cipher, cipher, contentEquals, copyTo, empty, endsWith, equalBytes, from, inside, inside, isClear, isEmpty, isPresent, isPresent, length, longCheckSum, nativePointer, readWrite, startsWith, startsWith, subSequence, to8bitString, toDebugString, toDebugString, wrap, wrap, writeMaxLong

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

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

Field Detail

address
```
protected long address
```

memory

protected net.openhft.chronicle.core.Memory memory

releasedHere

protected volatile Throwable releasedHere

maximumLimit
```
protected long maximumLimit
```

Constructor Detail

NativeBytesStore

public NativeBytesStore(long address,
                        long maximumLimit)

NativeBytesStore

public NativeBytesStore(long address,
                        long maximumLimit,
                        @Nullable
                        @Nullable Runnable deallocator,
                        boolean elastic)

Method Detail

wrap

@NotNull
public static @NotNull NativeBytesStore<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

uninitialized

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

nativeStore

@NotNull
public static @NotNull NativeBytesStore<Void> nativeStore(long capacity)
                                                            throws IllegalArgumentException

this is an elastic native store

Parameters:: capacity - of the buffer.
Throws:: IllegalArgumentException

nativeStoreWithFixedCapacity

@NotNull
public static @NotNull NativeBytesStore<Void> nativeStoreWithFixedCapacity(long capacity)
                                                                             throws IllegalArgumentException

Throws:: IllegalArgumentException

lazyNativeBytesStoreWithFixedCapacity

@NotNull
public static @NotNull NativeBytesStore<Void> lazyNativeBytesStoreWithFixedCapacity(long capacity)
                                                                                      throws IllegalArgumentException

Throws:: IllegalArgumentException

elasticByteBuffer

@NotNull
public static @NotNull NativeBytesStore<ByteBuffer> elasticByteBuffer()

elasticByteBuffer

@NotNull
public static @NotNull NativeBytesStore<ByteBuffer> elasticByteBuffer(int size,
                                                                               long maxSize)

from

@NotNull
public static @NotNull NativeBytesStore from(@NotNull
                                                      @NotNull String text)

from

@NotNull
public static @NotNull NativeBytesStore from(@NotNull
                                                      @NotNull byte[] bytes)

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

whether it uses direct memory or not.

canReadDirect

public boolean canReadDirect(long length)

init

public void init(@NotNull
                 @NotNull ByteBuffer bb,
                 boolean elastic)

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

move

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

Throws:: BufferUnderflowException

copy

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

Returns:: a copy of this BytesStore.

bytesForWrite

@NotNull
public @NotNull VanillaBytes<Underlying> bytesForWrite()
                                                         throws IllegalStateException

Returns:: a Bytes for writing to this BytesStore
Throws:: IllegalStateException

realCapacity
```
public long realCapacity()
```
Description copied from interface: RandomDataInput

Returns the actual capacity that can be potentially read.

Returns:

the actual capacity available before resizing.

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

The maximum limit you can set.

underlyingObject
```
@Nullable
public Underlying underlyingObject()
```
Returns:

the underlying object being wrapped, if there is one, or null if not.

zeroOut
```
@NotNull
public @NotNull NativeBytesStore<Underlying> zeroOut(long start,
                                                              long end)
```
Description copied from interface: BytesStore

Fill the BytesStore with zeros

Parameters:

start - first byte inclusive

end - last byte exclusive.

Returns:

this.

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.

addAndGetLong
```
public long addAndGetLong(long offset,
                          long adding)
                   throws BufferUnderflowException
```
Description copied from interface: RandomDataInput

Perform an atomic add and get operation for a 64-bit long

Parameters:

offset - to add and get

adding - value to add, can be 1

Returns:

the sum

Throws:

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

addAndGetInt
```
public int addAndGetInt(long offset,
                        int adding)
                 throws BufferUnderflowException
```
Description copied from interface: RandomDataInput

Perform an atomic add and get operation for a 32-bit int

Parameters:

offset - to add and get

adding - value to add, can be 1

Returns:

the sum

Throws:

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

translate

protected long translate(long offset)

reserve

public void reserve()
             throws IllegalStateException

Throws:: IllegalStateException

release

public void release()
             throws IllegalStateException

Throws:: IllegalStateException

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

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

readByte
```
public byte readByte(long offset)
```
Description copied from interface: RandomDataInput

Read byte at an offset

Parameters:

offset - to read

Returns:

the byte

readUnsignedByte
```
public int readUnsignedByte(long offset)
                     throws BufferUnderflowException
```
Description copied from interface: RandomDataInput

Read an unsigned byte at an offset

Parameters:

offset - to read

Returns:

the unsigned byte

Throws:

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

checkReleased
```
public void checkReleased()
```

readShort
```
public short readShort(long offset)
```
Description copied from interface: RandomDataInput

Read a short at an offset

Parameters:

offset - to read

Returns:

the short

readInt
```
public int readInt(long offset)
```
Description copied from interface: RandomDataInput

Read an int at an offset

Parameters:

offset - to read

Returns:

the int

readLong
```
public long readLong(long offset)
```
Description copied from interface: RandomDataInput

Read a long at an offset

Parameters:

offset - to read

Returns:

the long

readFloat
```
public float readFloat(long offset)
```
Description copied from interface: RandomDataInput

Read a float at an offset

Parameters:

offset - to read

Returns:

the float

readDouble
```
public double readDouble(long offset)
```
Description copied from interface: RandomDataInput

Read a double at an offset

Parameters:

offset - to read

Returns:

the double

readVolatileByte
```
public byte readVolatileByte(long offset)
```
Description copied from interface: RandomDataInput

Read a 8-bit byte from memory with a load barrier.

Parameters:

offset - to read

Returns:

the byte value

readVolatileShort
```
public short readVolatileShort(long offset)
```
Description copied from interface: RandomDataInput

Read a 16-bit short from memory with a load barrier.

Parameters:

offset - to read

Returns:

the short value

readVolatileInt
```
public int readVolatileInt(long offset)
```
Description copied from interface: RandomDataInput

Read a 32-bit int from memory with a load barrier.

Parameters:

offset - to read

Returns:

the int value

fencedRead
```
public int fencedRead(long offset)
```

readVolatileLong
```
public long readVolatileLong(long offset)
```
Description copied from interface: RandomDataInput

Read a 64-bit long from memory with a load barrier.

Parameters:

offset - to read

Returns:

the long value