NativeBytesStore (OpenHFT/Chronicle-Bytes 1.1.0 API)

java.lang.Object
- 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 Object
implements BytesStore<NativeBytesStore<Underlying>,Underlying>
```

Field Summary

Fields
Modifier and Type Field and Description

protected long address

protected net.openhft.chronicle.core.Memory memory
- Fields inherited from interface net.openhft.chronicle.bytes.RandomDataInput
  charToString

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

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
Modifier and Type	Method and Description
`long`	`address(long offset)` Obtain the underlying address.
`long`	`appendUTF(long pos, char[] chars, int offset, int length)`
`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()`
`static NativeBytesStore<ByteBuffer>`	`elasticByteBuffer()`
`static NativeBytesStore<ByteBuffer>`	`elasticByteBuffer(int size)`
`boolean`	`equals(Object obj)`
`static NativeBytesStore<Void>`	`lazyNativeBytesStoreWithFixedCapacity(long capacity)`
`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
`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
`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.
`long`	`realCapacity()`
`long`	`refCount()`
`void`	`release()`
`void`	`reserve()`
`void`	`setAddress(long address)`
`long`	`start()`
`String`	`toString()`
`Underlying`	`underlyingObject()`
`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)`
`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>`	`zeroOut(long start, long end)` Fill the BytesStore with zeros

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

Methods inherited from interface net.openhft.chronicle.bytes.BytesStore
byteCheckSum, bytesForRead, bytesStore, charAt, contentEquals, copyTo, endsWith, equalBytes, from, inside, isClear, length, nativePointer, safeLimit, startsWith, subSequence, to8bitString, toDebugString, wrap, wrap, wrap

Methods inherited from interface net.openhft.chronicle.bytes.RandomDataInput
addAndGetDouble, addAndGetFloat, addAndGetInt, addAndGetLong, copyTo, createCharToString, parseLong, printable, readBoolean, readUnsignedByte, readUnsignedInt, readUnsignedShort, readVolatileDouble, readVolatileFloat

Methods inherited from interface net.openhft.chronicle.bytes.RandomDataOutput
append, write, write, writeBoolean, writeByte, writeOrderedDouble, writeOrderedFloat, writeUnsignedByte, writeUnsignedInt, writeUnsignedShort

Methods inherited from interface net.openhft.chronicle.core.ReferenceCounted
close, release, releaseAll, tryReserve

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

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

- Field Detail
  - memory
```
@Nullable
protected net.openhft.chronicle.core.Memory memory
```
  - address
```
protected long address
```
- 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.
    
    Specified by:
    
    wrap in interface BytesStore<NativeBytesStore<Underlying>,Underlying>
    
    Parameters:
    
    bb - to wrap
    
    Returns:
    
    BytesStore
  - 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)
```
  - copy
```
@NotNull
public BytesStore<NativeBytesStore<Underlying>,Underlying> copy()
                                                                  throws IllegalStateException
```
    Specified by:
    
    copy in interface BytesStore<NativeBytesStore<Underlying>,Underlying>
    
    Returns:
    
    a copy of this BytesStore.
    
    Throws:
    
    IllegalStateException
  - bytesForWrite
```
public VanillaBytes<Underlying> bytesForWrite()
                                       throws IllegalStateException
```
    Specified by:
    
    bytesForWrite in interface BytesStore<NativeBytesStore<Underlying>,Underlying>
    
    Returns:
    
    a Bytes for writing to this BytesStore
    
    Throws:
    
    IllegalStateException
  - realCapacity
```
public long realCapacity()
```
    Specified by:
    
    realCapacity in interface BytesStore<NativeBytesStore<Underlying>,Underlying>
    
    Specified by:
    
    realCapacity in interface RandomDataInput
    
    Returns:
    
    the actual capacity available before resizing.
  - capacity
```
public long capacity()
```
    Specified by:
    
    capacity in interface BytesStore<NativeBytesStore<Underlying>,Underlying>
    
    Returns:
    
    The maximum limit you can set.
  - underlyingObject
```
@Nullable
public Underlying underlyingObject()
```
    Specified by:
    
    underlyingObject in interface BytesStore<NativeBytesStore<Underlying>,Underlying>
    
    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
    
    Specified by:
    
    zeroOut in interface BytesStore<NativeBytesStore<Underlying>,Underlying>
    
    Specified by:
    
    zeroOut in interface RandomDataOutput<NativeBytesStore<Underlying>>
    
    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
```
    Specified by:
    
    reserve in interface net.openhft.chronicle.core.ReferenceCounted
    
    Throws:
    
    IllegalStateException
  - release
```
public void release()
             throws IllegalStateException
```
    Specified by:
    
    release in interface net.openhft.chronicle.core.ReferenceCounted
    
    Throws:
    
    IllegalStateException
  - refCount
```
public long refCount()
```
    Specified by:
    
    refCount in interface net.openhft.chronicle.core.ReferenceCounted
  - readByte
```
public byte readByte(long offset)
```
    Description copied from interface: RandomDataInput
    
    Read byte at an offset
    
    Specified by:
    
    readByte in interface RandomDataInput
    
    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
    
    Specified by:
    
    readShort in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the short
  - readInt
```
public int readInt(long offset)
```
    Description copied from interface: RandomDataInput
    
    Read an int at an offset
    
    Specified by:
    
    readInt in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the int
  - readLong
```
public long readLong(long offset)
```
    Description copied from interface: RandomDataInput
    
    Read a long at an offset
    
    Specified by:
    
    readLong in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the long
  - readFloat
```
public float readFloat(long offset)
```
    Description copied from interface: RandomDataInput
    
    Read a float at an offset
    
    Specified by:
    
    readFloat in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the float
  - readDouble
```
public double readDouble(long offset)
```
    Description copied from interface: RandomDataInput
    
    Read a double at an offset
    
    Specified by:
    
    readDouble in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the double
  - readVolatileInt
```
public int readVolatileInt(long offset)
```
    Description copied from interface: RandomDataInput
    
    Read a 32-bit int from memory with a load barrier.
    
    Specified by:
    
    readVolatileInt in interface RandomDataInput
    
    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.
    
    Specified by:
    
    readVolatileLong in interface RandomDataInput
    
    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.
    
    Specified by:
    
    writeByte in interface RandomDataOutput<NativeBytesStore<Underlying>>
    
    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.
    
    Specified by:
    
    writeShort in interface RandomDataOutput<NativeBytesStore<Underlying>>
    
    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.
    
    Specified by:
    
    writeInt in interface RandomDataOutput<NativeBytesStore<Underlying>>
    
    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.
    
    Specified by:
    
    writeOrderedInt in interface RandomDataOutput<NativeBytesStore<Underlying>>
    
    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.
    
    Specified by:
    
    writeLong in interface RandomDataOutput<NativeBytesStore<Underlying>>
    
    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.
    
    Specified by:
    
    writeOrderedLong in interface RandomDataOutput<NativeBytesStore<Underlying>>
    
    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.
    
    Specified by:
    
    writeFloat in interface RandomDataOutput<NativeBytesStore<Underlying>>
    
    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.
    
    Specified by:
    
    writeDouble in interface RandomDataOutput<NativeBytesStore<Underlying>>
    
    Parameters:
    
    offset - to write to
    
    d - the value
    
    Returns:
    
    this
  - write
```
@NotNull
public NativeBytesStore<Underlying> write(long offsetInRDO,
                                                   byte[] bytes,
                                                   int offset,
                                                   int length)
```
    Specified by:
    
    write in interface RandomDataOutput<NativeBytesStore<Underlying>>
  - write
```
public void write(long offsetInRDO,
                  @NotNull
                  ByteBuffer bytes,
                  int offset,
                  int length)
```
    Specified by:
    
    write in interface RandomDataOutput<NativeBytesStore<Underlying>>
  - write
```
@NotNull
public NativeBytesStore<Underlying> write(long offsetInRDO,
                                                   @NotNull
                                                   RandomDataInput bytes,
                                                   long offset,
                                                   long length)
                                            throws BufferOverflowException,
                                                   BufferUnderflowException,
                                                   IORuntimeException
```
    Specified by:
    
    write in interface RandomDataOutput<NativeBytesStore<Underlying>>
    
    Throws:
    
    BufferOverflowException
    
    BufferUnderflowException
    
    IORuntimeException
  - 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.
    
    Specified by:
    
    nativeRead in interface RandomDataInput
    
    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
    
    Specified by:
    
    nativeWrite in interface RandomDataOutput<NativeBytesStore<Underlying>>
    
    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.
    
    Specified by:
    
    readIncompleteLong in interface RandomDataInput
    
    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
```
public long appendUTF(long pos,
                      char[] chars,
                      int offset,
                      int length)
```
  - 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,
                                   IORuntimeException
```
    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
    
    IORuntimeException
  - compareAndSwapDouble
```
public boolean compareAndSwapDouble(long offset,
                                    double expected,
                                    double value)
                             throws BufferOverflowException,
                                    IllegalArgumentException,
                                    IORuntimeException
```
    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
    
    IORuntimeException

Class NativeBytesStore<Underlying>

Field Summary

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

Constructor Summary

Method Summary

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

memory

address

Constructor Detail

NativeBytesStore

NativeBytesStore

Method Detail

wrap

nativeStore

nativeStoreWithFixedCapacity

lazyNativeBytesStoreWithFixedCapacity

elasticByteBuffer

elasticByteBuffer

copy

bytesForWrite

realCapacity

capacity

underlyingObject

zeroOut

compareAndSwapInt

compareAndSwapLong

start

reserve

release

refCount

readByte

checkReleased

readShort

readInt

readLong

readFloat

readDouble

readVolatileInt

readVolatileLong

writeByte

writeShort

writeInt

writeOrderedInt

writeLong

writeOrderedLong

writeFloat

writeDouble

write

write

write

address

toString

nativeRead

nativeWrite

readIncompleteLong

equals

setAddress

appendUTF

readPosition

writePosition

readRemaining

writeRemaining

readLimit

writeLimit

byteOrder

compareAndSwapFloat

compareAndSwapDouble