NativeBytesStore (OpenHFT/Chronicle-Bytes 2.21.93 API)

java.lang.Object
- net.openhft.chronicle.core.io.AbstractReferenceCounted
- - net.openhft.chronicle.bytes.internal.AbstractBytesStore<NativeBytesStore<Underlying>,Underlying>
  - - net.openhft.chronicle.bytes.internal.NativeBytesStore<Underlying>

All Implemented Interfaces:

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

Direct Known Subclasses:

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

Field Summary

Fields
Modifier and Type Field and Description

long address

protected long limit

long maximumLimit

net.openhft.chronicle.core.Memory memory
- Fields inherited from class net.openhft.chronicle.core.io.AbstractReferenceCounted
  referenceCounted, WARN_COUNT, WARN_NS
- Fields inherited from interface net.openhft.chronicle.bytes.RandomDataInput
  charToString
- Fields inherited from interface net.openhft.chronicle.core.io.ReferenceOwner
  INIT

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

Constructor Summary

Constructors
Modifier	Constructor and Description
	`NativeBytesStore(@NotNull ByteBuffer bb, boolean elastic, int maximumLimit)`
	`NativeBytesStore(long address, long limit)`
	`NativeBytesStore(long address, long limit, @Nullable Runnable deallocator, boolean elastic)`
`protected`	`NativeBytesStore(long address, long limit, @Nullable Runnable deallocator, boolean elastic, boolean monitored)`

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()` Returns the bytes sum of the readable bytes in this BytesStore.
`int`	`byteCheckSum(long position, long limit)` Returns the bytes sum between the specified indexes; start (inclusive) and end (exclusive).
`default ByteOrder`	`byteOrder()`
`@NotNull VanillaBytes<Underlying>`	`bytesForWrite()` Returns a Bytes that wraps this ByteStore from the `start` to the `realCapacity`.
`boolean`	`canReadDirect(long length)`
`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<NativeBytesStore<Underlying>,Underlying>`	`copy()`
`long`	`copyTo(@NotNull BytesStore store)` Returns the number of bytes that were copied from this BytesStore to a destination BytesStore.
`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)`
`static @NotNull NativeBytesStore`	`from(@NotNull byte[] bytes)`
`static @NotNull NativeBytesStore`	`from(@NotNull String text)` Returns a BytesStore using the bytes in a String.
`void`	`init(@NotNull ByteBuffer bb, boolean elastic)`
`boolean`	`isDirectMemory()`
`boolean`	`isEqual(long start, long length, String s)` Returns if a specified portion of this BytesStore is equal to a specified String.
`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
`protected void`	`performRelease()`
`long`	`read(long offsetInRDI, byte[] bytes, int offset, int length)`
`void`	`read8bit(long position, char[] chars, 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.
`default long`	`realReadRemaining()`
`default long`	`realWriteRemaining()`
`long`	`safeLimit()`
`void`	`setAddress(long address)`
`boolean`	`sharedMemory()`
`void`	`testAndSetInt(long offset, int expected, int value)`
`@NotNull String`	`toString()`
`@NotNull ByteBuffer`	`toTemporaryDirectByteBuffer()`
`long`	`translate(long offset)`
`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)`
`long`	`write8bit(long position, BytesStore bs)` Write the stop bit length and copy the BytesStore
`long`	`write8bit(long position, String s, int start, int 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 write position must be `readPosition() <= writePosition() && writePosition() <= writeLimit()`
`@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)` Fills the BytesStore with zeros.

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

Methods inherited from class net.openhft.chronicle.core.io.AbstractReferenceCounted
assertReferencesReleased, clearUsedByThread, 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
addAndGetDoubleNotAtomic, addAndGetFloatNotAtomic, addAndGetIntNotAtomic, addAndGetShortNotAtomic, addAndGetUnsignedByteNotAtomic, bytesForRead, bytesStore, charAt, cipher, cipher, contentEquals, copyTo, empty, endsWith, equalBytes, forFields, from, from, hash, inside, inside, isClear, isEmpty, length, nativePointer, readWrite, startsWith, startsWith, subSequence, to8bitString, toDebugString, toDebugString, wrap, wrap, writeMaxInt, 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.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, onReleased, onReleased

Field Detail

address
```
public long address
```

memory

public net.openhft.chronicle.core.Memory memory

maximumLimit
```
public long maximumLimit
```

limit
```
protected long limit
```

Constructor Detail

NativeBytesStore

public NativeBytesStore(@NotNull
                        @NotNull ByteBuffer bb,
                        boolean elastic,
                        int maximumLimit)

NativeBytesStore

public NativeBytesStore(long address,
                        long limit)

NativeBytesStore

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

NativeBytesStore

protected NativeBytesStore(long address,
                           long limit,
                           @Nullable
                           @Nullable Runnable deallocator,
                           boolean elastic,
                           boolean monitored)

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 - ByteBuffer
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)
```
Description copied from interface: BytesStore

Returns a BytesStore using the bytes in a String. The characters in the String are encoded using ISO_8859_1

Parameters:

text - a String

Returns:

BytesStore

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,
                 IllegalStateException

Throws:: BufferUnderflowException; IllegalStateException

copy

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

Returns:: a copy of this BytesStore.
Throws:: IllegalStateException

bytesForWrite
```
@NotNull
public @NotNull VanillaBytes<Underlying> bytesForWrite()
                                                         throws IllegalStateException
```
Description copied from interface: BytesStore

Returns a Bytes that wraps this ByteStore from the start to the realCapacity.
The returned Bytes is not elastic and can be both read and written using cursors.

Returns:

a Bytes that wraps this BytesStore

Throws:

IllegalStateException - if this BytesStore has been released

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

Fills 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)
                          throws IllegalStateException

Perform a 32-bit CAS at a given offset.

Parameters:: offset - to perform CAS; expected - value; value - to set
Returns:: true, if successful.
Throws:: IllegalStateException

testAndSetInt

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

Throws:: IllegalStateException

compareAndSwapLong

public boolean compareAndSwapLong(long offset,
                                  long expected,
                                  long value)
                           throws IllegalStateException

Perform a 64-bit CAS at a given offset.

Parameters:: offset - to perform CAS; expected - value; value - to set
Returns:: true, if successful.
Throws:: IllegalStateException

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
```
public long translate(long offset)
```

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

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

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