BytesStore (OpenHFT/Chronicle-Bytes 2.20.107 API)

All Superinterfaces:

CharSequence, RandomDataInput, RandomDataOutput<B>, net.openhft.chronicle.core.io.ReferenceCounted, net.openhft.chronicle.core.io.ReferenceOwner

All Known Subinterfaces:

Bytes<Underlying>

All Known Implementing Classes:

AbstractBytes, AbstractBytesStore, GuardedNativeBytes, HeapBytesStore, HexDumpBytes, MappedBytes, MappedBytesStore, NativeBytes, NativeBytes.NativeSubBytes, NativeBytesStore, NoBytesStore, OnHeapBytes, PointerBytesStore, ReadOnlyMappedBytesStore, ReleasedBytesStore, SubBytes, UncheckedBytes, UncheckedNativeBytes, VanillaBytes
```
public interface BytesStore<B extends BytesStore<B,Underlying>,Underlying>
extends RandomDataInput, RandomDataOutput<B>, net.openhft.chronicle.core.io.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
- Fields inherited from interface net.openhft.chronicle.core.io.ReferenceOwner
  INIT

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)` Deprecated.
`default double`	`addAndGetDoubleNotAtomic(long offset, double adding)` Deprecated.
`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)` Deprecated.
`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, int adding)` Deprecated.
`default int`	`addAndGetUnsignedShortNotAtomic(long offset, int adding)` Deprecated.
`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()`
`default int`	`byteCheckSum()` Return the bytes sum of the readable bytes.
`default int`	`byteCheckSum(long start, long end)`
`default ByteOrder`	`byteOrder()`
`default @NotNull Bytes<Underlying>`	`bytesForRead()`
`default @NotNull Bytes<Underlying>`	`bytesForWrite()`
`default @Nullable BytesStore`	`bytesStore()`
`long`	`capacity()`
`default char`	`charAt(int index)` Assume ISO-8859-1 encoding, subclasses can override this.
`default void`	`cipher(@NotNull Cipher cipher, @NotNull Bytes outBytes)`
`default void`	`cipher(@NotNull Cipher cipher, @NotNull Bytes outBytes, @NotNull ByteBuffer using1, @NotNull ByteBuffer using2)`
`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(@Nullable BytesStore bytesStore)` Compare the contents of the BytesStores.
`BytesStore<B,Underlying>`	`copy()`
`default long`	`copyTo(@NotNull BytesStore store)` Copy the data to another BytesStore as long as there is space available in the destination store.
`default void`	`copyTo(@NotNull OutputStream out)`
`static BytesStore`	`empty()`
`default boolean`	`endsWith(char c)` Does the BytesStore end with a character?
`default boolean`	`equalBytes(@NotNull BytesStore bytesStore, long length)` Check if a portion of a BytesStore matches this one.
`static BytesStore`	`from(@NotNull 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`	`inside(long offset, long buffer)`
`default boolean`	`isClear()` Returns if the `readPosition` is at the `start` and the `writeLimit` is at the `end`.
`boolean`	`isDirectMemory()`
`default boolean`	`isEmpty()`
`default boolean`	`isPresent()` Deprecated.
`default void`	`isPresent(boolean isPresent)` Deprecated.
`default int`	`length()` This method is inherited from CharSequence so result should be the length of the contained chars sequence although it actually returns the number of underlying bytes.
`default long`	`longCheckSum()` Deprecated.
`void`	`move(long from, long to, long length)`
`static @NotNull PointerBytesStore`	`nativePointer()`
`default long`	`readLimit()`
`default long`	`readPosition()` The read position must be start() <= readPosition() && readPosition() <= readLimit() && readPosition < safeLimit()
`default long`	`readRemaining()`
`default boolean`	`readWrite()`
`default long`	`realCapacity()` Returns the actual capacity that can be potentially read.
`default long`	`safeLimit()`
`boolean`	`sharedMemory()`
`default long`	`start()`
`default boolean`	`startsWith(@Nullable BytesStore bytesStore)`
`default boolean`	`startsWith(char c)` Does the BytesStore start with a character?
`default @NotNull CharSequence`	`subSequence(int start, int end)` Not supported.
`void`	`testAndSetInt(long offset, int expected, int value)`
`default @NotNull String`	`to8bitString()`
`default @NotNull String`	`toDebugString()` By default the maximum length of data shown is 256 characters.
`default @NotNull String`	`toDebugString(long maxLength)`
`Underlying`	`underlyingObject()`
`static HeapBytesStore<byte[]>`	`wrap(@NotNull byte[] bytes)` Wraps a byte[].
`static @NotNull BytesStore<?,ByteBuffer>`	`wrap(@NotNull ByteBuffer bb)` Wraps a ByteBuffer which can be either on heap or off heap.
`static @NotNull PointerBytesStore`	`wrap(long address, long length)` Return the addressForRead and length as a BytesStore
`default long`	`writeLimit()`
`default void`	`writeMaxInt(long offset, int atLeast)` Write a value which is not smaller.
`default void`	`writeMaxLong(long offset, long atLeast)` Write a value which is not smaller.
`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, canReadDirect, compareUtf8, copyTo, copyTo, createCharToString, fastHash, findByte, nativeRead, parseLong, peekUnsignedByte, peekVolatileInt, printable, read, readBoolean, readByte, readDouble, readFloat, readIncompleteLong, readInt, readLong, readShort, readUnsignedByte, readUnsignedInt, readUnsignedInt24, readUnsignedShort, readUtf8, readUtf8Limited, readUtf8Limited, readVolatileByte, readVolatileDouble, readVolatileFloat, readVolatileInt, readVolatileLong, readVolatileShort, subBytes, toByteArray, toTemporaryDirectByteBuffer

Methods inherited from interface net.openhft.chronicle.bytes.RandomDataOutput
append, append, nativeWrite, write, write, write, write, write, writeBoolean, writeByte, writeByte, writeDouble, writeFloat, writeInt, writeInt24, 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.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, toString

- Method Detail
  - from
```
static BytesStore from(@NotNull
                       @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
                                   @NotNull byte[] bytes)
```
    Wraps a byte[]. This means there is one copy in memory.
    
    Parameters:
    
    bytes - to wrap
    
    Returns:
    
    BytesStore
  - wrap
```
@NotNull
static @NotNull BytesStore<?,ByteBuffer> wrap(@NotNull
                                                       @NotNull ByteBuffer bb)
```
    Wraps a ByteBuffer which can be either on heap or off heap.
    
    Parameters:
    
    bb - to wrap
    
    Returns:
    
    BytesStore
  - nativePointer
```
@NotNull
static @NotNull PointerBytesStore nativePointer()
```
    Returns:
    
    a PointerBytesStore which can be set to any addressForRead
  - wrap
```
@NotNull
static @NotNull PointerBytesStore wrap(long address,
                                                long length)
```
    Return the addressForRead and length as a BytesStore
    
    Parameters:
    
    address - for the start
    
    length - of data
    
    Returns:
    
    as a BytesStore
  - empty
```
static BytesStore empty()
```
    Returns:
    
    an empty, fixed sized Bytes
  - isDirectMemory
```
boolean isDirectMemory()
```
    Returns:
    
    whether it uses direct memory or not.
  - copy
```
BytesStore<B,Underlying> copy()
```
    Returns:
    
    a copy of this BytesStore.
  - bytesForRead
```
@NotNull
default @NotNull Bytes<Underlying> bytesForRead()
                                                  throws IllegalStateException
```
    Returns:
    
    a Bytes to wrap this ByteStore from the start() to the realCapacity().
    
    Throws:
    
    IllegalStateException - if this Bytes has been released.
  - bytesForWrite
```
@NotNull
default @NotNull Bytes<Underlying> bytesForWrite()
                                                   throws IllegalStateException
```
    Returns:
    
    a Bytes for writing to this BytesStore
    
    Throws:
    
    IllegalStateException
  - isClear
```
default boolean isClear()
```
    Returns if the readPosition is at the start and the writeLimit is at the end.
    I.e start() == readPosition() && writeLimit() == capacity()
    
    Returns:
    
    if the readPosition is at the start and the writeLimit is at the end
  - realCapacity
```
default long realCapacity()
```
    Description copied from interface: RandomDataInput
    
    Returns the actual capacity that can be potentially read.
    
    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.
  - inside
```
default boolean inside(long offset,
                       long buffer)
```
  - 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 long copyTo(@NotNull
                    @NotNull BytesStore store)
```
    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
  - copyTo
```
default void copyTo(@NotNull
                    @NotNull OutputStream out)
             throws IOException
```
    Throws:
    
    IOException
  - zeroOut
```
@NotNull
default B zeroOut(long start,
                           long end)
```
    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.
  - length
```
default int length()
```
    This method is inherited from CharSequence so result should be the length of the contained chars sequence although it actually returns the number of underlying bytes. These 2 numbers are only the same if the encoding we are using is single char for single byte.
    
    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 @NotNull CharSequence subSequence(int start,
                                                   int end)
```
    Not supported.
    
    Specified by:
    
    subSequence in interface CharSequence
  - toDebugString
```
@NotNull
default @NotNull String toDebugString()
```
    By default the maximum length of data shown is 256 characters. Use toDebugString(long) if you want more.
    
    Returns:
    
    This BytesStore as a DebugString.
  - toDebugString
```
@NotNull
default @NotNull String toDebugString(long maxLength)
```
    Parameters:
    
    maxLength - the maximum len of the output
    
    Returns:
    
    This BytesStore as a DebugString.
  - bytesStore
```
@Nullable
default @Nullable BytesStore bytesStore()
```
    Returns:
    
    the underlying BytesStore
  - equalBytes
```
default boolean equalBytes(@NotNull
                           @NotNull BytesStore bytesStore,
                           long length)
                    throws BufferUnderflowException
```
    Check if a portion of a BytesStore matches this one.
    
    Parameters:
    
    bytesStore - to match against
    
    length - to match.
    
    Returns:
    
    true if the bytes up to min(length, this.length(), bytesStore.length()) matched.
    
    Throws:
    
    BufferUnderflowException
  - byteCheckSum
```
default int byteCheckSum()
                  throws net.openhft.chronicle.core.io.IORuntimeException
```
    Return the bytes sum of the readable bytes.
    
    Returns:
    
    unsigned byte sum.
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException
  - byteCheckSum
```
default int byteCheckSum(long start,
                         long end)
```
  - longCheckSum
```
@Deprecated
default long longCheckSum()
```
    Deprecated.
    
    Return the long sum of the readable bytes.
    
    Returns:
    
    signed long sum.
  - endsWith
```
default boolean endsWith(char c)
```
    Does the BytesStore end with a character?
    
    Parameters:
    
    c - to look for
    
    Returns:
    
    true if its the last character.
  - startsWith
```
default boolean startsWith(char c)
```
    Does the BytesStore start with a character?
    
    Parameters:
    
    c - to look for
    
    Returns:
    
    true if its the last character.
  - contentEquals
```
default boolean contentEquals(@Nullable
                              @Nullable BytesStore bytesStore)
```
    Compare the contents of the BytesStores.
    
    Parameters:
    
    bytesStore - to compare with
    
    Returns:
    
    true if they contain the same data.
  - startsWith
```
default boolean startsWith(@Nullable
                           @Nullable BytesStore bytesStore)
```
  - to8bitString
```
@NotNull
default @NotNull String to8bitString()
                                       throws IllegalArgumentException
```
    Throws:
    
    IllegalArgumentException
  - addAndGetByteNotAtomic
```
@Deprecated
default byte addAndGetByteNotAtomic(long offset,
                                                byte adding)
                                         throws BufferUnderflowException
```
    Deprecated.
    
    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
    
    Throws:
    
    BufferUnderflowException
  - addAndGetUnsignedByteNotAtomic
```
default int addAndGetUnsignedByteNotAtomic(long offset,
                                           int adding)
                                    throws BufferUnderflowException
```
    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
    
    Throws:
    
    BufferUnderflowException
  - addAndGetShortNotAtomic
```
default short addAndGetShortNotAtomic(long offset,
                                      short adding)
                               throws BufferUnderflowException
```
    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
    
    Throws:
    
    BufferUnderflowException
  - addAndGetUnsignedShortNotAtomic
```
@Deprecated
default int addAndGetUnsignedShortNotAtomic(long offset,
                                                        int adding)
                                                 throws BufferUnderflowException
```
    Deprecated.
    
    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
    
    Throws:
    
    BufferUnderflowException
  - addAndGetIntNotAtomic
```
default int addAndGetIntNotAtomic(long offset,
                                  int adding)
                           throws BufferUnderflowException
```
    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
    
    Throws:
    
    BufferUnderflowException
  - addAndGetUnsignedIntNotAtomic
```
@Deprecated
default long addAndGetUnsignedIntNotAtomic(long offset,
                                                       int adding)
                                                throws BufferUnderflowException
```
    Deprecated.
    
    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
    
    Throws:
    
    BufferUnderflowException
  - addAndGetLongNotAtomic
```
@Deprecated
default long addAndGetLongNotAtomic(long offset,
                                                long adding)
                                         throws BufferUnderflowException
```
    Deprecated.
    
    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
    
    Throws:
    
    BufferUnderflowException
  - addAndGetFloatNotAtomic
```
default float addAndGetFloatNotAtomic(long offset,
                                      float adding)
                               throws BufferUnderflowException
```
    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
    
    Throws:
    
    BufferUnderflowException
  - addAndGetDoubleNotAtomic
```
@Deprecated
default double addAndGetDoubleNotAtomic(long offset,
                                                    double adding)
                                             throws BufferUnderflowException
```
    Deprecated.
    
    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
    
    Throws:
    
    BufferUnderflowException
  - isPresent
```
@Deprecated
default void isPresent(boolean isPresent)
                            throws IllegalArgumentException
```
    Deprecated.
    
    Clear and set the flag for present.
    
    Parameters:
    
    isPresent - if there is data, or false if not.
    
    Throws:
    
    IllegalArgumentException
  - isPresent
```
@Deprecated
default boolean isPresent()
```
    Deprecated.
    
    Returns:
    
    if there is data, or false if not.
  - move
```
void move(long from,
          long to,
          long length)
   throws BufferUnderflowException
```
    Throws:
    
    BufferUnderflowException
  - writeMaxLong
```
default void writeMaxLong(long offset,
                          long atLeast)
                   throws BufferUnderflowException
```
    Write a value which is not smaller.
    
    Parameters:
    
    offset - to write to
    
    atLeast - value it is at least.
    
    Throws:
    
    BufferUnderflowException
  - writeMaxInt
```
default void writeMaxInt(long offset,
                         int atLeast)
                  throws BufferUnderflowException
```
    Write a value which is not smaller.
    
    Parameters:
    
    offset - to write to
    
    atLeast - value it is at least.
    
    Throws:
    
    BufferUnderflowException
  - isEmpty
```
default boolean isEmpty()
```
  - cipher
```
default void cipher(@NotNull
                    @NotNull Cipher cipher,
                    @NotNull
                    @NotNull Bytes outBytes,
                    @NotNull
                    @NotNull ByteBuffer using1,
                    @NotNull
                    @NotNull ByteBuffer using2)
             throws IllegalStateException
```
    Throws:
    
    IllegalStateException
  - cipher
```
default void cipher(@NotNull
                    @NotNull Cipher cipher,
                    @NotNull
                    @NotNull Bytes outBytes)
             throws IllegalStateException
```
    Throws:
    
    IllegalStateException
  - readWrite
```
default boolean readWrite()
```
    Returns:
    
    whether this BytesStore is writable.
  - 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()
```
  - addressForRead
```
long addressForRead(long offset)
             throws UnsupportedOperationException,
                    BufferUnderflowException
```
    Obtain the underlying addressForRead. This is for expert users only.
    
    Parameters:
    
    offset - within this buffer. addressForRead(start()) is the actual addressForRead of the first byte.
    
    Returns:
    
    the underlying addressForRead of the buffer
    
    Throws:
    
    UnsupportedOperationException - if the underlying buffer is on the heap
    
    BufferUnderflowException - if the offset is before the start() or the after the capacity()
  - addressForRead
```
default long addressForRead(long offset,
                            int buffer)
                     throws UnsupportedOperationException,
                            BufferUnderflowException
```
    Throws:
    
    UnsupportedOperationException
    
    BufferUnderflowException
  - addressForWrite
```
long addressForWrite(long offset)
              throws UnsupportedOperationException,
                     BufferOverflowException
```
    Obtain the underlying addressForRead. This is for expert users only.
    
    Parameters:
    
    offset - within this buffer. addressForRead(start()) is the actual addressForRead of the first byte.
    
    Returns:
    
    the underlying addressForRead of the buffer
    
    Throws:
    
    UnsupportedOperationException - if the underlying buffer is on the heap
    
    BufferOverflowException - if the offset is before the start() or the after the capacity()
  - addressForWritePosition
```
long addressForWritePosition()
                      throws UnsupportedOperationException,
                             BufferOverflowException
```
    Throws:
    
    UnsupportedOperationException
    
    BufferOverflowException
  - byteOrder
```
default ByteOrder byteOrder()
```
  - compareAndSwapInt
```
boolean compareAndSwapInt(long offset,
                          int expected,
                          int value)
                   throws BufferOverflowException
```
    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
  - testAndSetInt
```
void testAndSetInt(long offset,
                   int expected,
                   int value)
```
  - compareAndSwapLong
```
boolean compareAndSwapLong(long offset,
                           long expected,
                           long value)
                    throws BufferOverflowException
```
    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
  - compareAndSwapFloat
```
default boolean compareAndSwapFloat(long offset,
                                    float expected,
                                    float value)
                             throws BufferOverflowException
```
    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
  - compareAndSwapDouble
```
default boolean compareAndSwapDouble(long offset,
                                     double expected,
                                     double value)
                              throws BufferOverflowException
```
    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
  - sharedMemory
```
boolean sharedMemory()
```
    Returns:
    
    true if these Bytes use shared memory.

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

Field Summary

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

Fields inherited from interface net.openhft.chronicle.core.io.ReferenceOwner

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.io.ReferenceCounted

Methods inherited from interface net.openhft.chronicle.core.io.ReferenceOwner

Methods inherited from interface java.lang.CharSequence

Method Detail

from

wrap

wrap

nativePointer

wrap

empty

isDirectMemory

copy

bytesForRead

bytesForWrite

isClear

realCapacity

capacity

underlyingObject

inside

inside

safeLimit

copyTo

copyTo

zeroOut

length

charAt

subSequence

toDebugString

toDebugString

bytesStore

equalBytes

byteCheckSum

byteCheckSum

longCheckSum

endsWith

startsWith

contentEquals

startsWith

to8bitString

addAndGetByteNotAtomic

addAndGetUnsignedByteNotAtomic

addAndGetShortNotAtomic

addAndGetUnsignedShortNotAtomic

addAndGetIntNotAtomic

addAndGetUnsignedIntNotAtomic

addAndGetLongNotAtomic

addAndGetFloatNotAtomic

addAndGetDoubleNotAtomic

isPresent

isPresent

move

writeMaxLong

writeMaxInt

isEmpty

cipher

cipher

readWrite

start

readPosition

writePosition

readRemaining

writeRemaining

readLimit

writeLimit

addressForRead

addressForRead

addressForWrite

addressForWritePosition

byteOrder

compareAndSwapInt

testAndSetInt

compareAndSwapLong

compareAndSwapFloat