BytesStore (OpenHFT/Chronicle-Bytes 1.1.4 API)

All Superinterfaces:

AutoCloseable, CharSequence, Closeable, RandomDataInput, RandomDataOutput<B>, net.openhft.chronicle.core.ReferenceCounted

All Known Subinterfaces:

Bytes<Underlying>

All Known Implementing Classes:

AbstractBytes, ExpectedBytesStore, HeapBytesStore, MappedBytes, MappedBytesStore, NativeBytes, NativeBytesStore, NoBytesStore, PointerBytesStore, UncheckedBytes, UncheckedNativeBytes, VanillaBytes
```
public interface BytesStore<B extends BytesStore<B,Underlying>,Underlying>
extends RandomDataInput, RandomDataOutput<B>, net.openhft.chronicle.core.ReferenceCounted, CharSequence
```
A immutable reference to some bytes with fixed extents. This can be shared safely across thread provided the data referenced is accessed in a thread safe manner. Only offset access within the capacity is possible.

Field Summary
- Fields inherited from interface net.openhft.chronicle.bytes.RandomDataInput
  charToString

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`default byte`	`addAndGetByteNotAtomic(long offset, byte adding)` Perform a not atomic add and get operation for a byte value.
`default double`	`addAndGetDoubleNotAtomic(long offset, double adding)` Perform a not atomic add and get operation for a double value.
`default float`	`addAndGetFloatNotAtomic(long offset, float adding)` Perform a not atomic add and get operation for a float value.
`default int`	`addAndGetIntNotAtomic(long offset, int adding)` Perform a not atomic add and get operation for an int value.
`default long`	`addAndGetLongNotAtomic(long offset, long adding)` Perform a not atomic add and get operation for a long value.
`default short`	`addAndGetShortNotAtomic(long offset, short adding)` Perform a not atomic add and get operation for a short value.
`default int`	`addAndGetUnsignedByteNotAtomic(long offset, int adding)` Perform a not atomic add and get operation for an unsigned byte value.
`default long`	`addAndGetUnsignedIntNotAtomic(long offset, long adding)` Perform a not atomic add and get operation for an unsigned int value.
`default int`	`addAndGetUnsignedShortNotAtomic(long offset, int adding)` Perform a not atomic add and get operation for an unsigned short value.
`long`	`address(long offset)` Obtain the underlying address.
`default int`	`byteCheckSum()` Return the bytes sum of the readable bytes.
`default ByteOrder`	`byteOrder()`
`default Bytes<Underlying>`	`bytesForRead()`
`default Bytes<Underlying>`	`bytesForWrite()`
`default BytesStore`	`bytesStore()`
`long`	`capacity()`
`default char`	`charAt(int index)` Assume ISO-8859-1 encoding, subclasses can override this.
`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.
`default boolean`	`contentEquals(BytesStore bytesStore)` Compare the contents of the BytesStores.
`BytesStore<B,Underlying>`	`copy()`
`default void`	`copyTo(BytesStore store)` Copy the data to another BytesStore
`default boolean`	`endsWith(char c)` Does the BytesStore end with a character?
`default boolean`	`equalBytes(BytesStore bytesStore, long length)` Check if a portion of a BytesStore matches this one.
`static BytesStore`	`from(CharSequence cs)` This method builds a BytesStore using the bytes in a CharSequence.
`default boolean`	`inside(long offset)` Use this test to determine if an offset is considered safe.
`default boolean`	`isClear()` The Bytes are clear if start() == readPosition() && writeLimit() == capacity()
`default int`	`length()`
`default long`	`longCheckSum()` Return the long sum of the readable bytes.
`static PointerBytesStore`	`nativePointer()`
`default long`	`readLimit()`
`default long`	`readPosition()` The read position must be start() <= readPosition() && readPosition() <= readLimit() && readPosition < safeLimit()
`default long`	`readRemaining()`
`default long`	`realCapacity()`
`default long`	`safeLimit()`
`default long`	`start()`
`default boolean`	`startsWith(char c)` Does the BytesStore start with a character?
`default CharSequence`	`subSequence(int start, int end)` Not supported.
`default String`	`to8bitString()`
`default String`	`toDebugString()`
`Underlying`	`underlyingObject()`
`static HeapBytesStore<byte[]>`	`wrap(byte[] bytes)` Wraps a byte[].
`static BytesStore<?,ByteBuffer>`	`wrap(ByteBuffer bb)` Wraps a ByteBuffer which can be either on heap or off heap.
`static BytesStore`	`wrap(CharSequence cs)` Deprecated. Use from(CharSequence) instead.
`static PointerBytesStore`	`wrap(long address, long length)` Return the address and length as a BytesStore
`default long`	`writeLimit()`
`default long`	`writePosition()` The read position must be readPosition() <= writePosition() && writePosition() <= writeLimit()
`default long`	`writeRemaining()`
`default B`	`zeroOut(long start, long end)` Fill the BytesStore with zeros

Methods inherited from interface net.openhft.chronicle.bytes.RandomDataInput
addAndGetDouble, addAndGetFloat, addAndGetInt, addAndGetLong, copyTo, createCharToString, findByte, nativeRead, parseLong, printable, readBoolean, readByte, readDouble, readFloat, readIncompleteLong, readInt, readLong, readShort, readUnsignedByte, readUnsignedInt, readUnsignedShort, readUtf8, readUtf8Limited, readUtf8Limited, readVolatileByte, readVolatileDouble, readVolatileFloat, readVolatileInt, readVolatileLong, readVolatileShort, subBytes

Methods inherited from interface net.openhft.chronicle.bytes.RandomDataOutput
append, nativeWrite, write, write, write, write, write, writeBoolean, writeByte, writeByte, writeDouble, writeFloat, writeInt, writeLong, writeOrderedDouble, writeOrderedFloat, writeOrderedInt, writeOrderedLong, writeShort, writeUnsignedByte, writeUnsignedInt, writeUnsignedShort, writeUtf8, writeUtf8Limited, writeVolatileByte, writeVolatileDouble, writeVolatileFloat, writeVolatileInt, writeVolatileLong, writeVolatileShort

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

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

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

- Method Detail
  - wrap
```
@Deprecated
static BytesStore wrap(@NotNull
                                   CharSequence cs)
```
    Deprecated. Use from(CharSequence) instead.
  - from
```
static BytesStore from(@NotNull
                       CharSequence cs)
```
    This method builds a BytesStore using the bytes in a CharSequence. This chars are encoded using ISO_8859_1
    
    Parameters:
    
    cs - to convert
    
    Returns:
    
    BytesStore
  - wrap
```
static HeapBytesStore<byte[]> wrap(@NotNull
                                   byte[] bytes)
```
    Wraps a byte[]. This means there is one copy in memory.
    
    Parameters:
    
    bytes - to wrap
    
    Returns:
    
    BytesStore
  - wrap
```
static BytesStore<?,ByteBuffer> wrap(@NotNull
                                     ByteBuffer bb)
```
    Wraps a ByteBuffer which can be either on heap or off heap.
    
    Parameters:
    
    bb - to wrap
    
    Returns:
    
    BytesStore
  - nativePointer
```
@NotNull
static PointerBytesStore nativePointer()
```
    Returns:
    
    a PointerBytesStore which can be set to any address
  - wrap
```
static PointerBytesStore wrap(long address,
                              long length)
```
    Return the address and length as a BytesStore
    
    Parameters:
    
    address - for the start
    
    length - of data
    
    Returns:
    
    as a BytesStore
  - copy
```
BytesStore<B,Underlying> copy()
                       throws IllegalArgumentException
```
    Returns:
    
    a copy of this BytesStore.
    
    Throws:
    
    IllegalArgumentException
  - bytesForRead
```
default Bytes<Underlying> bytesForRead()
                                throws IllegalStateException
```
    Returns:
    
    a Bytes to wrap this ByteStore from the start() to the realCapacity().
    
    Throws:
    
    IllegalStateException
  - bytesForWrite
```
default Bytes<Underlying> bytesForWrite()
                                 throws IllegalStateException
```
    Returns:
    
    a Bytes for writing to this BytesStore
    
    Throws:
    
    IllegalStateException
  - isClear
```
default boolean isClear()
```
    The Bytes are clear if start() == readPosition() && writeLimit() == capacity()
    
    Returns:
    
    is the Bytes clear?
  - realCapacity
```
default long realCapacity()
```
    Specified by:
    
    realCapacity in interface RandomDataInput
    
    Returns:
    
    the actual capacity available before resizing.
  - capacity
```
long capacity()
```
    Returns:
    
    The maximum limit you can set.
  - underlyingObject
```
@Nullable
Underlying underlyingObject()
```
    Returns:
    
    the underlying object being wrapped, if there is one, or null if not.
  - inside
```
default boolean inside(long offset)
```
    Use this test to determine if an offset is considered safe.
  - safeLimit
```
default long safeLimit()
```
    Returns:
    
    how many bytes can be safely read, i.e. what is the real capacity of the underlying data.
  - copyTo
```
default void copyTo(@NotNull
                    BytesStore store)
             throws IllegalStateException,
                    IORuntimeException
```
    Copy the data to another BytesStore
    
    Parameters:
    
    store - to copy to
    
    Throws:
    
    IllegalStateException
    
    IORuntimeException
  - zeroOut
```
default B zeroOut(long start,
                  long end)
           throws IllegalArgumentException,
                  IORuntimeException
```
    Fill the BytesStore with zeros
    
    Specified by:
    
    zeroOut in interface RandomDataOutput<B extends BytesStore<B,Underlying>>
    
    Parameters:
    
    start - first byte inclusive
    
    end - last byte exclusive.
    
    Returns:
    
    this.
    
    Throws:
    
    IORuntimeException - if the underlying buffer fails to resize.
    
    IllegalArgumentException
  - length
```
default int length()
```
    Specified by:
    
    length in interface CharSequence
    
    Returns:
    
    length in bytes to read or Integer.MAX_VALUE if longer.
  - charAt
```
default char charAt(int index)
             throws IndexOutOfBoundsException
```
    Assume ISO-8859-1 encoding, subclasses can override this.
    
    Specified by:
    
    charAt in interface CharSequence
    
    Throws:
    
    IndexOutOfBoundsException
  - subSequence
```
@NotNull
default CharSequence subSequence(int start,
                                          int end)
```
    Not supported.
    
    Specified by:
    
    subSequence in interface CharSequence
  - toDebugString
```
@NotNull
default String toDebugString()
```
    Returns:
    
    This BytesStore as a DebugString.
  - bytesStore
```
default BytesStore bytesStore()
```
    Returns:
    
    the underlying BytesStore
  - equalBytes
```
default boolean equalBytes(@NotNull
                           BytesStore bytesStore,
                           long length)
                    throws BufferUnderflowException,
                           IORuntimeException
```
    Check if a portion of a BytesStore matches this one.
    
    Parameters:
    
    bytesStore - to match against
    
    length - to match.
    
    Returns:
    
    true if the bytes and length matched.
    
    Throws:
    
    BufferUnderflowException
    
    IORuntimeException
  - byteCheckSum
```
default int byteCheckSum()
                  throws IORuntimeException
```
    Return the bytes sum of the readable bytes.
    
    Returns:
    
    unsigned byte sum.
    
    Throws:
    
    IORuntimeException
  - longCheckSum
```
default long longCheckSum()
                   throws IORuntimeException
```
    Return the long sum of the readable bytes.
    
    Returns:
    
    signed long sum.
    
    Throws:
    
    IORuntimeException
  - endsWith
```
default boolean endsWith(char c)
                  throws IORuntimeException
```
    Does the BytesStore end with a character?
    
    Parameters:
    
    c - to look for
    
    Returns:
    
    true if its the last character.
    
    Throws:
    
    IORuntimeException
  - startsWith
```
default boolean startsWith(char c)
                    throws IORuntimeException
```
    Does the BytesStore start with a character?
    
    Parameters:
    
    c - to look for
    
    Returns:
    
    true if its the last character.
    
    Throws:
    
    IORuntimeException
  - contentEquals
```
default boolean contentEquals(@Nullable
                              BytesStore bytesStore)
                       throws IORuntimeException
```
    Compare the contents of the BytesStores.
    
    Parameters:
    
    bytesStore - to compare with
    
    Returns:
    
    true if they contain the same data.
    
    Throws:
    
    IORuntimeException
  - to8bitString
```
default String to8bitString()
                     throws IORuntimeException,
                            IllegalArgumentException
```
    Throws:
    
    IORuntimeException
    
    IllegalArgumentException
  - addAndGetByteNotAtomic
```
default byte addAndGetByteNotAtomic(long offset,
                                    byte adding)
```
    Perform a not atomic add and get operation for a byte value.
    
    Parameters:
    
    offset - to add and get
    
    adding - value to add, can be 1
    
    Returns:
    
    the sum
  - addAndGetUnsignedByteNotAtomic
```
default int addAndGetUnsignedByteNotAtomic(long offset,
                                           int adding)
```
    Perform a not atomic add and get operation for an unsigned byte value. This method does not check for unsigned byte overflow.
    
    Parameters:
    
    offset - to add and get
    
    adding - value to add, can be 1
    
    Returns:
    
    the sum
  - addAndGetShortNotAtomic
```
default short addAndGetShortNotAtomic(long offset,
                                      short adding)
```
    Perform a not atomic add and get operation for a short value.
    
    Parameters:
    
    offset - to add and get
    
    adding - value to add, can be 1
    
    Returns:
    
    the sum
  - addAndGetUnsignedShortNotAtomic
```
default int addAndGetUnsignedShortNotAtomic(long offset,
                                            int adding)
```
    Perform a not atomic add and get operation for an unsigned short value. This method does not check for unsigned short overflow.
    
    Parameters:
    
    offset - to add and get
    
    adding - value to add, can be 1
    
    Returns:
    
    the sum
  - addAndGetIntNotAtomic
```
default int addAndGetIntNotAtomic(long offset,
                                  int adding)
```
    Perform a not atomic add and get operation for an int value.
    
    Parameters:
    
    offset - to add and get
    
    adding - value to add, can be 1
    
    Returns:
    
    the sum
  - addAndGetUnsignedIntNotAtomic
```
default long addAndGetUnsignedIntNotAtomic(long offset,
                                           long adding)
```
    Perform a not atomic add and get operation for an unsigned int value. This method does not check for unsigned int overflow.
    
    Parameters:
    
    offset - to add and get
    
    adding - value to add, can be 1
    
    Returns:
    
    the sum
  - addAndGetLongNotAtomic
```
default long addAndGetLongNotAtomic(long offset,
                                    long adding)
```
    Perform a not atomic add and get operation for a long value.
    
    Parameters:
    
    offset - to add and get
    
    adding - value to add, can be 1
    
    Returns:
    
    the sum
  - addAndGetFloatNotAtomic
```
default float addAndGetFloatNotAtomic(long offset,
                                      float adding)
```
    Perform a not atomic add and get operation for a float value.
    
    Parameters:
    
    offset - to add and get
    
    adding - value to add, can be 1
    
    Returns:
    
    the sum
  - addAndGetDoubleNotAtomic
```
default double addAndGetDoubleNotAtomic(long offset,
                                        double adding)
```
    Perform a not atomic add and get operation for a double value.
    
    Parameters:
    
    offset - to add and get
    
    adding - value to add, can be 1
    
    Returns:
    
    the sum
  - start
```
default long start()
```
    Returns:
    
    The smallest position allowed in this buffer.
  - readPosition
```
default long readPosition()
```
    The read position must be start() <= readPosition() && readPosition() <= readLimit() && readPosition < safeLimit()
    
    Returns:
    
    position to read from.
  - writePosition
```
default long writePosition()
```
    The read position must be readPosition() <= writePosition() && writePosition() <= writeLimit()
    
    Returns:
    
    position to write to.
  - readRemaining
```
default long readRemaining()
```
    Returns:
    
    How many more bytes can we read.
  - writeRemaining
```
default long writeRemaining()
```
    Returns:
    
    How many more bytes can we written.
  - readLimit
```
default long readLimit()
```
    Returns:
    
    the highest offset or position allowed for this buffer.
  - writeLimit
```
default long writeLimit()
```
  - address
```
long address(long offset)
      throws UnsupportedOperationException,
             IllegalArgumentException
```
    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
    
    IllegalArgumentException - if the offset is before the start() or the after the capacity()
  - byteOrder
```
default ByteOrder byteOrder()
```
  - compareAndSwapInt
```
boolean compareAndSwapInt(long offset,
                          int expected,
                          int value)
                   throws BufferOverflowException,
                          IllegalArgumentException,
                          IORuntimeException
```
    Perform a 32-bit CAS at a given offset.
    
    Parameters:
    
    offset - to perform CAS
    
    expected - value
    
    value - to set
    
    Returns:
    
    true, if successful.
    
    Throws:
    
    BufferOverflowException
    
    IllegalArgumentException
    
    IORuntimeException
  - compareAndSwapLong
```
boolean compareAndSwapLong(long offset,
                           long expected,
                           long value)
                    throws BufferOverflowException,
                           IllegalArgumentException,
                           IORuntimeException
```
    Perform a 64-bit CAS at a given offset.
    
    Parameters:
    
    offset - to perform CAS
    
    expected - value
    
    value - to set
    
    Returns:
    
    true, if successful.
    
    Throws:
    
    BufferOverflowException
    
    IllegalArgumentException
    
    IORuntimeException
  - compareAndSwapFloat
```
default 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
```
default 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

Interface BytesStore<B extends BytesStore<B,Underlying>,Underlying>

Field Summary

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

Method Summary

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

Method Detail

wrap

from

wrap

wrap

nativePointer

wrap

copy

bytesForRead

bytesForWrite

isClear

realCapacity

capacity

underlyingObject

inside

safeLimit

copyTo

zeroOut

length

charAt

subSequence

toDebugString

bytesStore

equalBytes

byteCheckSum

longCheckSum

endsWith

startsWith

contentEquals

to8bitString

addAndGetByteNotAtomic

addAndGetUnsignedByteNotAtomic

addAndGetShortNotAtomic

addAndGetUnsignedShortNotAtomic

addAndGetIntNotAtomic

addAndGetUnsignedIntNotAtomic

addAndGetLongNotAtomic

addAndGetFloatNotAtomic

addAndGetDoubleNotAtomic

start

readPosition

writePosition

readRemaining

writeRemaining

readLimit

writeLimit

address

byteOrder

compareAndSwapInt

compareAndSwapLong

compareAndSwapFloat

compareAndSwapDouble