NativeBytesStore (OpenHFT/Chronicle-Bytes 1.7.0 API)

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

All Implemented Interfaces:

Closeable, AutoCloseable, 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 Error releasedHere
- Fields inherited from interface net.openhft.chronicle.bytes.RandomDataInput
  charToString

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

Constructor Summary

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

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`long`	`address(long offset)` Obtain the underlying address.
`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()`
`VanillaBytes<Underlying>`	`bytesForWrite()`
`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.
`BytesStore<NativeBytesStore<Underlying>,Underlying>`	`copy()`
`long`	`copyTo(BytesStore store)` Copy the data to another BytesStore as long as there is space available in the destination store.
`long`	`copyTo(NativeBytesStore store)`
`static NativeBytesStore<ByteBuffer>`	`elasticByteBuffer()`
`static NativeBytesStore<ByteBuffer>`	`elasticByteBuffer(int size, long maxSize)`
`boolean`	`equals(Object obj)`
`void`	`init(ByteBuffer bb, boolean elastic)`
`static 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 NativeBytesStore<Void>`	`nativeStore(long capacity)` this is an elastic native store
`static 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
`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`	`realCapacity()`
`long`	`refCount()`
`void`	`release()`
`void`	`reserve()`
`void`	`setAddress(long address)`
`boolean`	`sharedMemory()`
`long`	`start()`
`String`	`toString()`
`ByteBuffer`	`toTemporaryDirectByteBuffer()`
`Underlying`	`underlyingObject()`
`void`	`uninit()`
`static <T> NativeBytesStore<T>`	`uninitialized()`
`static NativeBytesStore<ByteBuffer>`	`wrap(ByteBuffer bb)` Wraps a ByteBuffer which can be either on heap or off heap.
`NativeBytesStore<Underlying>`	`write(long offsetInRDO, byte[] bytes, int offset, int length)`
`void`	`write(long offsetInRDO, ByteBuffer bytes, int offset, int length)`
`NativeBytesStore<Underlying>`	`write(long offsetInRDO, RandomDataInput bytes, long offset, long length)`
`void`	`write0(long offsetInRDO, RandomDataInput bytes, long offset, long length)`
`NativeBytesStore<Underlying>`	`writeByte(long offset, byte i8)` Write an unsigned byte at an offset.
`NativeBytesStore<Underlying>`	`writeDouble(long offset, double d)` Write a double at an offset.
`NativeBytesStore<Underlying>`	`writeFloat(long offset, float f)` Write a float at an offset.
`NativeBytesStore<Underlying>`	`writeInt(long offset, int i32)` Write an int at an offset.
`default long`	`writeLimit()`
`NativeBytesStore<Underlying>`	`writeLong(long offset, long i64)` Write a long at an offset.
`NativeBytesStore<Underlying>`	`writeOrderedInt(long offset, int i)` Perform a non stalling write with a store barrier.
`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()`
`NativeBytesStore<Underlying>`	`writeShort(long offset, short i16)` Write a short at an offset.
`NativeBytesStore<Underlying>`	`writeVolatileByte(long offset, byte i8)`
`NativeBytesStore<Underlying>`	`writeVolatileInt(long offset, int i32)`
`NativeBytesStore<Underlying>`	`writeVolatileLong(long offset, long i64)`
`NativeBytesStore<Underlying>`	`writeVolatileShort(long offset, short i16)`
`NativeBytesStore<Underlying>`	`zeroOut(long start, long end)` Fill the BytesStore with zeros

Methods inherited from class net.openhft.chronicle.bytes.AbstractBytesStore
hashCode

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, contentEquals, copyTo, empty, endsWith, equalBytes, from, inside, isClear, isEmpty, isNative, isPresent, isPresent, length, longCheckSum, nativePointer, safeLimit, startsWith, startsWith, subSequence, to8bitString, toDebugString, toDebugString, wrap, wrap, wrap, writeMaxLong

Methods inherited from interface net.openhft.chronicle.bytes.RandomDataInput
addAndGetDouble, addAndGetFloat, addAndGetInt, addAndGetLong, compareUtf8, copyTo, copyTo, createCharToString, fastHash, findByte, parseLong, printable, readBoolean, readUnsignedByte, 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
close, release, releaseAll, tryReserve

Methods inherited from interface net.openhft.chronicle.core.io.Closeable
closeQuietly, isClosed, notifyClosing

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

Field Detail

address
```
protected long address
```

memory

@Nullable
protected net.openhft.chronicle.core.Memory memory

releasedHere
```
protected volatile Error releasedHere
```

maximumLimit
```
protected long maximumLimit
```

Constructor Detail

NativeBytesStore

public NativeBytesStore(long address,
                        long maximumLimit)

NativeBytesStore

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

Method Detail

wrap

@NotNull
public static NativeBytesStore<ByteBuffer> wrap(@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> NativeBytesStore<T> uninitialized()

nativeStore

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

this is an elastic native store

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

nativeStoreWithFixedCapacity

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

Throws:: IllegalArgumentException

lazyNativeBytesStoreWithFixedCapacity

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

Throws:: IllegalArgumentException

elasticByteBuffer

@NotNull
public static NativeBytesStore<ByteBuffer> elasticByteBuffer()

elasticByteBuffer

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

init

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

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

move

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

copy

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

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

bytesForWrite

public VanillaBytes<Underlying> bytesForWrite()
                                       throws IllegalStateException

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

realCapacity
```
public long realCapacity()
```
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 NativeBytesStore<Underlying> zeroOut(long start,
                                                     long end)
                                              throws IllegalArgumentException

Description copied from interface: BytesStore

Fill the BytesStore with zeros

Parameters:: start - first byte inclusive; end - last byte exclusive.
Returns:: this.
Throws:: IllegalArgumentException

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.

start
```
public long start()
```
Returns:

The smallest position allowed in this buffer.

reserve

public void reserve()
             throws IllegalStateException

Throws:: IllegalStateException

release

public void release()
             throws IllegalStateException

Throws:: IllegalStateException

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

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

Read byte at an offset

Parameters:

offset - to read

Returns:

the byte

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

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

writeByte
```
@NotNull
public NativeBytesStore<Underlying> writeByte(long offset,
                                                       byte i8)
```
Description copied from interface: RandomDataOutput

Write an unsigned byte at an offset.

Parameters:

offset - to write to

i8 - the value

Returns:

this

writeShort
```
@NotNull
public NativeBytesStore<Underlying> writeShort(long offset,
                                                        short i16)
```
Description copied from interface: RandomDataOutput

Write a short at an offset.

Parameters:

offset - to write to

i16 - the value

Returns:

this

writeInt
```
@NotNull
public NativeBytesStore<Underlying> writeInt(long offset,
                                                      int i32)
```
Description copied from interface: RandomDataOutput

Write an int at an offset.

Parameters:

offset - to write to

i32 - the value

Returns:

this

writeOrderedInt
```
@NotNull
public NativeBytesStore<Underlying> writeOrderedInt(long offset,
                                                             int i)
```
Description copied from interface: RandomDataOutput

Perform a non stalling write with a store barrier.

Parameters:

offset - to write to

i - value to write

Returns:

this

writeLong
```
@NotNull
public NativeBytesStore<Underlying> writeLong(long offset,
                                                       long i64)
```
Description copied from interface: RandomDataOutput

Write a long at an offset.

Parameters:

offset - to write to

i64 - the value

Returns:

this

writeOrderedLong
```
@NotNull
public NativeBytesStore<Underlying> writeOrderedLong(long offset,
                                                              long i)
```
Description copied from interface: RandomDataOutput

Perform a non stalling write with a store barrier.

Parameters:

offset - to write to

i - value to write

Returns:

this

writeFloat
```
@NotNull
public NativeBytesStore<Underlying> writeFloat(long offset,
                                                        float f)
```
Description copied from interface: RandomDataOutput

Write a float at an offset.

Parameters:

offset - to write to

f - the value

Returns:

this

writeDouble
```
@NotNull
public NativeBytesStore<Underlying> writeDouble(long offset,
                                                         double d)
```
Description copied from interface: RandomDataOutput

Write a double at an offset.

Parameters:

offset - to write to

d - the value

Returns:

this

writeVolatileByte

@NotNull
public NativeBytesStore<Underlying> writeVolatileByte(long offset,
                                                               byte i8)

writeVolatileShort

@NotNull
public NativeBytesStore<Underlying> writeVolatileShort(long offset,
                                                                short i16)

writeVolatileInt

@NotNull
public NativeBytesStore<Underlying> writeVolatileInt(long offset,
                                                              int i32)

writeVolatileLong

@NotNull
public NativeBytesStore<Underlying> writeVolatileLong(long offset,
                                                               long i64)

write

@NotNull
public NativeBytesStore<Underlying> write(long offsetInRDO,
                                                   byte[] bytes,
                                                   int offset,
                                                   int length)

write

public void write(long offsetInRDO,
                  @NotNull
                  ByteBuffer bytes,
                  int offset,
                  int length)

write

@NotNull
public NativeBytesStore<Underlying> write(long offsetInRDO,
                                                   @NotNull
                                                   RandomDataInput bytes,
                                                   long offset,
                                                   long length)
                                            throws BufferOverflowException,
                                                   BufferUnderflowException

Throws:: BufferOverflowException; BufferUnderflowException

write0

public void write0(long offsetInRDO,
                   @NotNull
                   RandomDataInput bytes,
                   long offset,
                   long length)

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

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

toString in interface CharSequence

Overrides:

toString in class Object

nativeRead
```
public void nativeRead(long position,
                       long address,
                       long size)
```
Description copied from interface: RandomDataInput

expert level method for copying data to native memory.

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

Parameters:

address - in native memory to copy from

position - in BytesStore to copy to

size - in bytes

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

Read a long which is zero padded (high bytes) if the available bytes is less than 8. If the offset is at or beyond the readLimit, this will return 0L.

Parameters:

offset - to read from

Returns:

the long which might be padded.

equals
```
public boolean equals(Object obj)
```
Overrides:

equals in class Object

setAddress
```
public void setAddress(long address)
```

appendUTF

@Deprecated
public long appendUTF(long pos,
                                  char[] chars,
                                  int offset,
                                  int length)

Deprecated.

appendUtf8

public long appendUtf8(long pos,
                       char[] chars,
                       int offset,
                       int length)

copyTo
```
public long copyTo(@NotNull
                   BytesStore store)
            throws IllegalStateException
```
Description copied from interface: BytesStore

Copy the data to another BytesStore as long as there is space available in the destination store.

Parameters:

store - to copy to

Returns:

how many bytes were copied

Throws:

IllegalStateException

copyTo

public long copyTo(NativeBytesStore store)

toTemporaryDirectByteBuffer

public ByteBuffer toTemporaryDirectByteBuffer()

byteCheckSum
```
public int byteCheckSum()
                 throws net.openhft.chronicle.core.io.IORuntimeException
```
Description copied from interface: BytesStore

Return the bytes sum of the readable bytes.

Returns:

unsigned byte sum.

Throws:

net.openhft.chronicle.core.io.IORuntimeException

byteCheckSum

public int byteCheckSum(long position,
                        long limit)

sharedMemory
```
public boolean sharedMemory()
```
Returns:

true if these Bytes use shared memory.

read

public long read(long offsetInRDI,
                 byte[] bytes,
                 int offset,
                 int length)

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

Read an unsigned byte at an offset, or -1

Specified by:

peekUnsignedByte in interface RandomDataInput

Overrides:

peekUnsignedByte in class AbstractBytesStore<NativeBytesStore<Underlying>,Underlying>

Parameters:

offset - to read

Returns:

the unsigned byte or -1

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

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

compareAndSwapDouble

public boolean compareAndSwapDouble(long offset,
                                    double expected,
                                    double value)
                             throws BufferOverflowException,
                                    IllegalArgumentException

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

Class NativeBytesStore<Underlying>

Field Summary

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

Constructor Summary

Method Summary

Methods inherited from class net.openhft.chronicle.bytes.AbstractBytesStore

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

Field Detail

address

memory

releasedHere

maximumLimit

Constructor Detail

NativeBytesStore

NativeBytesStore

Method Detail

wrap

uninitialized

nativeStore

nativeStoreWithFixedCapacity

lazyNativeBytesStoreWithFixedCapacity

elasticByteBuffer

elasticByteBuffer

init

uninit

move

copy

bytesForWrite

realCapacity

capacity

underlyingObject

zeroOut

compareAndSwapInt

compareAndSwapLong

start

reserve

release

refCount

readByte

checkReleased

readShort

readInt

readLong

readFloat

readDouble

readVolatileByte

readVolatileShort

readVolatileInt

readVolatileLong

writeByte

writeShort

writeInt

writeOrderedInt

writeLong

writeOrderedLong

writeFloat

writeDouble

writeVolatileByte

writeVolatileShort

writeVolatileInt

writeVolatileLong

write

write

write

write0

address

toString

nativeRead

nativeWrite

readIncompleteLong

equals

setAddress

appendUTF

appendUtf8