SingletonEmptyByteStore (OpenHFT/Chronicle-Bytes 2.23ea10 API)

java.lang.Object
- net.openhft.chronicle.bytes.internal.SingletonEmptyByteStore

All Implemented Interfaces:

CharSequence, BytesStore<EmptyByteStore,Void>, EmptyByteStore, RandomDataInput, RandomDataOutput<EmptyByteStore>, net.openhft.chronicle.core.io.ReferenceCounted, net.openhft.chronicle.core.io.ReferenceOwner
```
public final class SingletonEmptyByteStore
extends Object
implements EmptyByteStore
```

Field Summary

Fields
Modifier and Type Field and Description

static EmptyByteStore INSTANCE
- Fields inherited from interface net.openhft.chronicle.bytes.RandomDataInput
  charToString
- Fields inherited from interface net.openhft.chronicle.core.io.ReferenceOwner
  INIT, TMP

Fields
Modifier and Type	Field and Description
`static EmptyByteStore`	`INSTANCE`

Method Summary

All Methods Instance Methods Concrete Methods Default Methods
Modifier and Type	Method and Description
`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 ByteOrder`	`byteOrder()`
`@NotNull Bytes<Void>`	`bytesForRead()` Returns a Bytes that wraps this ByteStore from the `start` to the `realCapacity`.
`@NotNull Bytes<Void>`	`bytesForWrite()` Returns a Bytes that wraps this ByteStore from the `start` to the `realCapacity`.
`long`	`capacity()`
`char`	`charAt(int index)` Assume ISO-8859-1 encoding, subclasses can override this.
`@NotNull IntStream`	`chars()`
`@NotNull IntStream`	`codePoints()`
`boolean`	`compareAndSwapInt(long offset, int expected, int value)` Perform a 32-bit CAS at a given offset.
`boolean`	`compareAndSwapLong(long offset, long expected, long value)` Perform a 64-bit CAS at a given offset.
`@NotNull EmptyByteStore`	`copy()`
`long`	`copyTo(@NotNull BytesStore store)` Returns the number of bytes that were copied from this BytesStore to a destination BytesStore.
`boolean`	`equalBytes(@NotNull BytesStore bytesStore, long length)` Returns if a portion of a specified BytesStore matches this BytesStore.
`boolean`	`equals(Object obj)`
`int`	`hashCode()`
`boolean`	`inside(long offset)` Returns if a specified offset is inside this BytesStore limits.
`boolean`	`inside(long offset, long buffer)` Returns if a number of bytes starting from an offset are inside this ByteStore limits.
`boolean`	`isDirectMemory()`
`boolean`	`isImmutableEmptyByteStore()` Returns if this ByteStore is an immutable empty ByteStore or if it is backed by an immutable empty ByteStore.
`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`	`lengthWritten(long startPosition)` Typically this calculates the difference however for HexDumpBytes it's not as simple.
`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.
`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
`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
`int`	`readInt(long offset)` Read an int at an offset
`default long`	`readLimit()` If the resource is closed, the returned value is unspecified.
`long`	`readLong(long offset)` Read a long at an offset
`default long`	`readPosition()` Returns the read position.
`default long`	`readRemaining()` Returns the remaining bytes that can be read.
`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.
`default long`	`realReadRemaining()` If the resource is closed, the returned value is unspecified.
`default long`	`realWriteRemaining()` If the resource is closed, the returned value is unspecified.
`int`	`refCount()`
`void`	`release(net.openhft.chronicle.core.io.ReferenceOwner owner)`
`void`	`releaseLast(net.openhft.chronicle.core.io.ReferenceOwner id)`
`void`	`reserve(net.openhft.chronicle.core.io.ReferenceOwner owner)`
`boolean`	`reservedBy(net.openhft.chronicle.core.io.ReferenceOwner owner)`
`boolean`	`sharedMemory()`
`default long`	`start()`
`@NotNull CharSequence`	`subSequence(int start, int end)` This method constructs a new `BytesStore`, memory storage type (heap or native) is preserved.
`void`	`testAndSetInt(long offset, int expected, int value)`
`@NotNull String`	`toString()`
`boolean`	`tryReserve(net.openhft.chronicle.core.io.ReferenceOwner owner)`
`Void`	`underlyingObject()`
`@NotNull EmptyByteStore`	`write(long offsetInRDO, byte[] byteArray, int offset, int length)` Copies the provided `byteArray` to this Bytes object starting at `writeOffset` taking content starting at `readOffset` but copying at most `length` bytes.
`void`	`write(long offsetInRDO, @NotNull ByteBuffer bytes, int offset, int length)` Copy from ByteBuffer into this.
`@NotNull EmptyByteStore`	`write(long writeOffset, @NotNull RandomDataInput bytes, long readOffset, long length)` Copy from RandomDataInput into this.
`long`	`write8bit(long position, @NotNull BytesStore bs)` Write the stop bit length and copy the BytesStore
`long`	`write8bit(long position, @NotNull String s, int start, int length)`
`@NotNull EmptyByteStore`	`writeByte(long offset, byte i8)` Write an unsigned byte at an offset.
`@NotNull EmptyByteStore`	`writeDouble(long offset, double d)` Write a double at an offset.
`@NotNull EmptyByteStore`	`writeFloat(long offset, float d)` Write a float at an offset.
`@NotNull EmptyByteStore`	`writeInt(long offset, int i)` Write an int at an offset.
`default long`	`writeLimit()` Returns the write limit.
`@NotNull EmptyByteStore`	`writeLong(long offset, long i)` Write a long at an offset.
`@NotNull EmptyByteStore`	`writeOrderedInt(long offset, int i)` Perform a non stalling write with a store barrier.
`@NotNull EmptyByteStore`	`writeOrderedLong(long offset, long i)` Perform a non stalling write with a store barrier.
`default long`	`writePosition()` Returns the write position.
`default long`	`writeRemaining()` If the resource is closed, the returned value is unspecified.
`@NotNull EmptyByteStore`	`writeShort(long offset, short i)` Write a short at an offset.
`@NotNull EmptyByteStore`	`writeVolatileByte(long offset, byte i8)`
`@NotNull EmptyByteStore`	`writeVolatileInt(long offset, int i32)`
`@NotNull EmptyByteStore`	`writeVolatileLong(long offset, long i64)`
`@NotNull EmptyByteStore`	`writeVolatileShort(long offset, short i16)`
`@NotNull EmptyByteStore`	`zeroOut(long start, long end)` Fills the BytesStore with zeros.

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

Methods inherited from interface net.openhft.chronicle.bytes.BytesStore
addAndGetDouble, addAndGetDoubleNotAtomic, addAndGetFloat, addAndGetFloatNotAtomic, addAndGetInt, addAndGetIntNotAtomic, addAndGetLong, addAndGetShortNotAtomic, addAndGetUnsignedByteNotAtomic, byteCheckSum, byteCheckSum, bytesStore, cipher, cipher, compareAndSwapDouble, compareAndSwapFloat, contentEquals, copyTo, elasticByteBuffer, empty, endsWith, forFields, from, from, from, hash, isClear, isEmpty, isEqual, lazyNativeBytesStoreWithFixedCapacity, nativePointer, nativeStore, nativeStoreFrom, nativeStoreWithFixedCapacity, readWrite, realCapacity, safeLimit, startsWith, startsWith, to8bitString, toDebugString, toDebugString, wrap, wrap, wrap, writeMaxInt, writeMaxLong

Methods inherited from interface net.openhft.chronicle.bytes.RandomDataInput
canReadDirect, canReadDirect, compareUtf8, copyTo, copyTo, createCharToString, fastHash, findByte, parseLong, peekVolatileInt, printable, read, readBoolean, readIncompleteLong, readUnsignedByte, readUnsignedInt, readUnsignedInt24, readUnsignedShort, readUtf8, readUtf8Limited, readUtf8Limited, readVolatileDouble, readVolatileFloat, subBytes, toByteArray, toTemporaryDirectByteBuffer

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

Methods inherited from interface net.openhft.chronicle.core.io.ReferenceCounted
releaseLast, reserveTransfer

Methods inherited from interface net.openhft.chronicle.core.io.ReferenceOwner
referenceId, referenceName, temporary

- Field Detail
  - INSTANCE
```
public static final EmptyByteStore INSTANCE
```
- Method Detail
  - reserve
```
public void reserve(net.openhft.chronicle.core.io.ReferenceOwner owner)
             throws IllegalStateException
```
    Specified by:
    
    reserve in interface net.openhft.chronicle.core.io.ReferenceCounted
    
    Throws:
    
    IllegalStateException
  - release
```
public void release(net.openhft.chronicle.core.io.ReferenceOwner owner)
             throws IllegalStateException
```
    Specified by:
    
    release in interface net.openhft.chronicle.core.io.ReferenceCounted
    
    Throws:
    
    IllegalStateException
  - releaseLast
```
public void releaseLast(net.openhft.chronicle.core.io.ReferenceOwner id)
                 throws IllegalStateException
```
    Specified by:
    
    releaseLast in interface net.openhft.chronicle.core.io.ReferenceCounted
    
    Throws:
    
    IllegalStateException
  - refCount
```
public int refCount()
```
    Specified by:
    
    refCount in interface net.openhft.chronicle.core.io.ReferenceCounted
  - tryReserve
```
public boolean tryReserve(net.openhft.chronicle.core.io.ReferenceOwner owner)
```
    Specified by:
    
    tryReserve in interface net.openhft.chronicle.core.io.ReferenceCounted
  - reservedBy
```
public boolean reservedBy(net.openhft.chronicle.core.io.ReferenceOwner owner)
```
    Specified by:
    
    reservedBy in interface net.openhft.chronicle.core.io.ReferenceCounted
  - writeByte
```
@NotNull
public @NotNull EmptyByteStore writeByte(long offset,
                                                  byte i8)
```
    Description copied from interface: RandomDataOutput
    
    Write an unsigned byte at an offset.
    
    Specified by:
    
    writeByte in interface RandomDataOutput<EmptyByteStore>
    
    Parameters:
    
    offset - to write to
    
    i8 - the value
    
    Returns:
    
    this
  - writeShort
```
@NotNull
public @NotNull EmptyByteStore writeShort(long offset,
                                                   short i)
```
    Description copied from interface: RandomDataOutput
    
    Write a short at an offset.
    
    Specified by:
    
    writeShort in interface RandomDataOutput<EmptyByteStore>
    
    Parameters:
    
    offset - to write to
    
    i - the value
    
    Returns:
    
    this
  - writeInt
```
@NotNull
public @NotNull EmptyByteStore writeInt(long offset,
                                                 int i)
```
    Description copied from interface: RandomDataOutput
    
    Write an int at an offset.
    
    Specified by:
    
    writeInt in interface RandomDataOutput<EmptyByteStore>
    
    Parameters:
    
    offset - to write to
    
    i - the value
    
    Returns:
    
    this
  - writeOrderedInt
```
@NotNull
public @NotNull EmptyByteStore 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<EmptyByteStore>
    
    Parameters:
    
    offset - to write to
    
    i - value to write
    
    Returns:
    
    this
  - writeLong
```
@NotNull
public @NotNull EmptyByteStore writeLong(long offset,
                                                  long i)
```
    Description copied from interface: RandomDataOutput
    
    Write a long at an offset.
    
    Specified by:
    
    writeLong in interface RandomDataOutput<EmptyByteStore>
    
    Parameters:
    
    offset - to write to
    
    i - the value
    
    Returns:
    
    this
  - writeOrderedLong
```
@NotNull
public @NotNull EmptyByteStore 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<EmptyByteStore>
    
    Parameters:
    
    offset - to write to
    
    i - value to write
    
    Returns:
    
    this
  - writeFloat
```
@NotNull
public @NotNull EmptyByteStore writeFloat(long offset,
                                                   float d)
```
    Description copied from interface: RandomDataOutput
    
    Write a float at an offset.
    
    Specified by:
    
    writeFloat in interface RandomDataOutput<EmptyByteStore>
    
    Parameters:
    
    offset - to write to
    
    d - the value
    
    Returns:
    
    this
  - writeDouble
```
@NotNull
public @NotNull EmptyByteStore writeDouble(long offset,
                                                    double d)
```
    Description copied from interface: RandomDataOutput
    
    Write a double at an offset.
    
    Specified by:
    
    writeDouble in interface RandomDataOutput<EmptyByteStore>
    
    Parameters:
    
    offset - to write to
    
    d - the value
    
    Returns:
    
    this
  - writeVolatileByte
```
@NotNull
public @NotNull EmptyByteStore writeVolatileByte(long offset,
                                                          byte i8)
```
    Specified by:
    
    writeVolatileByte in interface RandomDataOutput<EmptyByteStore>
  - writeVolatileShort
```
@NotNull
public @NotNull EmptyByteStore writeVolatileShort(long offset,
                                                           short i16)
```
    Specified by:
    
    writeVolatileShort in interface RandomDataOutput<EmptyByteStore>
  - writeVolatileInt
```
@NotNull
public @NotNull EmptyByteStore writeVolatileInt(long offset,
                                                         int i32)
```
    Specified by:
    
    writeVolatileInt in interface RandomDataOutput<EmptyByteStore>
  - writeVolatileLong
```
@NotNull
public @NotNull EmptyByteStore writeVolatileLong(long offset,
                                                          long i64)
```
    Specified by:
    
    writeVolatileLong in interface RandomDataOutput<EmptyByteStore>
  - write
```
@NotNull
public @NotNull EmptyByteStore write(long offsetInRDO,
                                              byte[] byteArray,
                                              int offset,
                                              int length)
```
    Description copied from interface: RandomDataOutput
    
    Copies the provided byteArray to this Bytes object starting at writeOffset taking content starting at readOffset but copying at most length bytes.
    Does not update cursors e.g. writePosition()
    
    Specified by:
    
    write in interface RandomDataOutput<EmptyByteStore>
    
    Parameters:
    
    offsetInRDO - non-negative offset to write to
    
    byteArray - non-null copy from byteArray
    
    offset - non-negative copy from offset
    
    length - non-negative length to copy
    
    Returns:
    
    this
  - write
```
public void write(long offsetInRDO,
                  @NotNull
                  @NotNull ByteBuffer bytes,
                  int offset,
                  int length)
```
    Description copied from interface: RandomDataOutput
    
    Copy from ByteBuffer into this.
    Does not update cursors e.g. writePosition()
    
    Specified by:
    
    write in interface RandomDataOutput<EmptyByteStore>
    
    Parameters:
    
    offsetInRDO - offset to write to
    
    bytes - copy from bytes
    
    offset - copy from offset
  - write
```
@NotNull
public @NotNull EmptyByteStore write(long writeOffset,
                                              @NotNull
                                              @NotNull RandomDataInput bytes,
                                              long readOffset,
                                              long length)
```
    Description copied from interface: RandomDataOutput
    
    Copy from RandomDataInput into this. Does not bump writePosition() nor RandomCommon.readPosition()
    
    Specified by:
    
    write in interface RandomDataOutput<EmptyByteStore>
    
    Parameters:
    
    writeOffset - offset to write to
    
    bytes - copy from bytes
    
    readOffset - copy from offset
    
    Returns:
    
    this
  - 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
  - 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
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the unsigned byte or -1
  - 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
  - readVolatileByte
```
public byte readVolatileByte(long offset)
                      throws BufferUnderflowException
```
    Description copied from interface: RandomDataInput
    
    Read a 8-bit byte from memory with a load barrier.
    
    Specified by:
    
    readVolatileByte in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the byte value
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readVolatileShort
```
public short readVolatileShort(long offset)
                        throws BufferUnderflowException
```
    Description copied from interface: RandomDataInput
    
    Read a 16-bit short from memory with a load barrier.
    
    Specified by:
    
    readVolatileShort in interface RandomDataInput
    
    Parameters:
    
    offset - to read
    
    Returns:
    
    the short value
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readVolatileInt
```
public int readVolatileInt(long offset)
                    throws BufferUnderflowException
```
    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
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - readVolatileLong
```
public long readVolatileLong(long offset)
                      throws BufferUnderflowException
```
    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
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the limits of the Bytes
  - isDirectMemory
```
public boolean isDirectMemory()
```
    Specified by:
    
    isDirectMemory in interface BytesStore<EmptyByteStore,Void>
    
    Returns:
    
    whether it uses direct memory or not.
  - copy
```
@NotNull
public @NotNull EmptyByteStore copy()
```
    Specified by:
    
    copy in interface BytesStore<EmptyByteStore,Void>
    
    Returns:
    
    a copy of this BytesStore.
  - bytesForRead
```
@NotNull
public @NotNull Bytes<Void> bytesForRead()
                                           throws IllegalStateException
```
    Description copied from interface: BytesStore
    
    Returns a Bytes that wraps this ByteStore from the start to the realCapacity.
    The returned Bytes is not elastic and can be both read and written using cursors.
    
    Specified by:
    
    bytesForRead in interface BytesStore<EmptyByteStore,Void>
    
    Returns:
    
    a Bytes that wraps this ByteStore
    
    Throws:
    
    IllegalStateException - if this Bytes has been released
  - capacity
```
public long capacity()
```
    Specified by:
    
    capacity in interface BytesStore<EmptyByteStore,Void>
    
    Returns:
    
    The maximum limit you can set.
  - underlyingObject
```
public Void underlyingObject()
```
    Specified by:
    
    underlyingObject in interface BytesStore<EmptyByteStore,Void>
    
    Returns:
    
    the underlying object being wrapped, if there is one, or null if not.
  - inside
```
public boolean inside(long offset)
```
    Description copied from interface: BytesStore
    
    Returns if a specified offset is inside this BytesStore limits.
    Use this test to determine if an offset is considered safe.
    
    Specified by:
    
    inside in interface BytesStore<EmptyByteStore,Void>
    
    Parameters:
    
    offset - the specified offset to check
    
    Returns:
    
    true if offset is safe
  - inside
```
public boolean inside(long offset,
                      long buffer)
```
    Description copied from interface: BytesStore
    
    Returns if a number of bytes starting from an offset are inside this ByteStore limits.
    
    Specified by:
    
    inside in interface BytesStore<EmptyByteStore,Void>
    
    Parameters:
    
    offset - the starting index to check
    
    buffer - the number of bytes after the offset to check
    
    Returns:
    
    true if the bytes between the offset and offset+buffer are inside the BytesStore
  - copyTo
```
public long copyTo(@NotNull
                   @NotNull BytesStore store)
```
    Description copied from interface: BytesStore
    
    Returns the number of bytes that were copied from this BytesStore to a destination BytesStore.
    Copies the data to another BytesStore as long as space is available in the destination BytesStore.
    
    Specified by:
    
    copyTo in interface BytesStore<EmptyByteStore,Void>
    
    Parameters:
    
    store - the BytesStore to copy to
    
    Returns:
    
    how many bytes were copied
  - 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<EmptyByteStore>
    
    Parameters:
    
    address - in native memory to copy from
    
    position - in BytesStore to copy to
    
    size - in bytes
  - write8bit
```
public long write8bit(long position,
                      @NotNull
                      @NotNull BytesStore bs)
```
    Description copied from interface: RandomDataOutput
    
    Write the stop bit length and copy the BytesStore
    
    Specified by:
    
    write8bit in interface RandomDataOutput<EmptyByteStore>
    
    Parameters:
    
    position - to write
    
    bs - to copy.
    
    Returns:
    
    the offset after the char sequence written, in this RandomDataOutput
  - write8bit
```
public long write8bit(long position,
                      @NotNull
                      @NotNull String s,
                      int start,
                      int length)
```
    Specified by:
    
    write8bit in interface RandomDataOutput<EmptyByteStore>
  - 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
  - compareAndSwapInt
```
public boolean compareAndSwapInt(long offset,
                                 int expected,
                                 int value)
```
    Description copied from interface: RandomDataInput
    
    Perform a 32-bit CAS at a given offset.
    
    Specified by:
    
    compareAndSwapInt in interface BytesStore<EmptyByteStore,Void>
    
    Specified by:
    
    compareAndSwapInt in interface RandomDataInput
    
    Specified by:
    
    compareAndSwapInt in interface RandomDataOutput<EmptyByteStore>
    
    Parameters:
    
    offset - to perform CAS
    
    expected - value
    
    value - to set
    
    Returns:
    
    true, if successful.
  - testAndSetInt
```
public void testAndSetInt(long offset,
                          int expected,
                          int value)
```
    Specified by:
    
    testAndSetInt in interface RandomDataInput
    
    Specified by:
    
    testAndSetInt in interface RandomDataOutput<EmptyByteStore>
  - compareAndSwapLong
```
public boolean compareAndSwapLong(long offset,
                                  long expected,
                                  long value)
```
    Description copied from interface: RandomDataInput
    
    Perform a 64-bit CAS at a given offset.
    
    Specified by:
    
    compareAndSwapLong in interface BytesStore<EmptyByteStore,Void>
    
    Specified by:
    
    compareAndSwapLong in interface RandomDataInput
    
    Specified by:
    
    compareAndSwapLong in interface RandomDataOutput<EmptyByteStore>
    
    Parameters:
    
    offset - to perform CAS
    
    expected - value
    
    value - to set
    
    Returns:
    
    true, if successful.
  - equalBytes
```
public boolean equalBytes(@NotNull
                          @NotNull BytesStore bytesStore,
                          long length)
```
    Description copied from interface: BytesStore
    
    Returns if a portion of a specified BytesStore matches this BytesStore.
    
    Specified by:
    
    equalBytes in interface BytesStore<EmptyByteStore,Void>
    
    Parameters:
    
    bytesStore - the BytesStore to match against
    
    length - the length to match
    
    Returns:
    
    true if the bytes up to min(length, this.length(), bytesStore.length()) matched.
  - move
```
public void move(long from,
                 long to,
                 long length)
```
    Specified by:
    
    move in interface BytesStore<EmptyByteStore,Void>
  - addressForRead
```
public long addressForRead(long offset)
                    throws 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:
    
    BufferUnderflowException - if the offset is before the start() or the after the capacity()
  - addressForWrite
```
public long addressForWrite(long offset)
                     throws 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:
    
    BufferOverflowException - if the offset is before the start() or the after the capacity()
  - addressForWritePosition
```
public long addressForWritePosition()
                             throws UnsupportedOperationException,
                                    BufferOverflowException
```
    Throws:
    
    UnsupportedOperationException
    
    BufferOverflowException
  - bytesForWrite
```
@NotNull
public @NotNull Bytes<Void> bytesForWrite()
```
    Description copied from interface: BytesStore
    
    Returns a Bytes that wraps this ByteStore from the start to the realCapacity.
    The returned Bytes is not elastic and can be both read and written using cursors.
    
    Specified by:
    
    bytesForWrite in interface BytesStore<EmptyByteStore,Void>
    
    Returns:
    
    a Bytes that wraps this BytesStore
  - sharedMemory
```
public boolean sharedMemory()
```
    Returns:
    
    true if these Bytes use shared memory.
  - zeroOut
```
@NotNull
public @NotNull EmptyByteStore zeroOut(long start,
                                                long end)
                                         throws IllegalStateException
```
    Description copied from interface: BytesStore
    
    Fills the BytesStore with zeros.
    
    Specified by:
    
    zeroOut in interface BytesStore<EmptyByteStore,Void>
    
    Specified by:
    
    zeroOut in interface RandomDataOutput<EmptyByteStore>
    
    Parameters:
    
    start - first byte inclusive
    
    end - last byte exclusive
    
    Returns:
    
    this
    
    Throws:
    
    IllegalStateException
  - isImmutableEmptyByteStore
```
public boolean isImmutableEmptyByteStore()
```
    Description copied from interface: BytesStore
    
    Returns if this ByteStore is an immutable empty ByteStore or if it is backed by an immutable empty ByteStore.
    
    Specified by:
    
    isImmutableEmptyByteStore in interface BytesStore<EmptyByteStore,Void>
    
    Returns:
    
    if immutable empty or backed by such
  - toString
```
@NotNull
public @NotNull String toString()
```
    Specified by:
    
    toString in interface CharSequence
    
    Overrides:
    
    toString in class Object
  - chars
```
@NotNull
public @NotNull IntStream chars()
```
    Specified by:
    
    chars in interface CharSequence
  - codePoints
```
@NotNull
public @NotNull IntStream codePoints()
```
    Specified by:
    
    codePoints in interface CharSequence
  - length
```
public int length()
```
    Description copied from interface: BytesStore
    
    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
    
    Specified by:
    
    length in interface BytesStore<EmptyByteStore,Void>
    
    Returns:
    
    length in bytes to read or Integer.MAX_VALUE if longer.
  - charAt
```
public char charAt(int index)
            throws IndexOutOfBoundsException
```
    Description copied from interface: BytesStore
    
    Assume ISO-8859-1 encoding, subclasses can override this.
    
    Specified by:
    
    charAt in interface CharSequence
    
    Specified by:
    
    charAt in interface BytesStore<EmptyByteStore,Void>
    
    Throws:
    
    IndexOutOfBoundsException
  - subSequence
```
@NotNull
public @NotNull CharSequence subSequence(int start,
                                                  int end)
```
    Description copied from interface: BytesStore
    
    This method constructs a new BytesStore, memory storage type (heap or native) is preserved.
    
    Specified by:
    
    subSequence in interface CharSequence
    
    Specified by:
    
    subSequence in interface BytesStore<EmptyByteStore,Void>
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - start
```
public long start()
```
    Returns:
    
    The smallest position allowed in this buffer.
  - readPosition
```
public long readPosition()
```
    Returns the read position.
    The read position is start() <= readPosition() && readPosition() <= readLimit() && readPosition < safeLimit()
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    position to read from.
  - writePosition
```
public long writePosition()
```
    Returns the write position. The write position is readPosition() <= writePosition() && writePosition() <= writeLimit()
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    position to write to.
  - lengthWritten
```
public long lengthWritten(long startPosition)
```
    Typically this calculates the difference however for HexDumpBytes it's not as simple.
    If the resource is closed, the returned value is unspecified.
    
    Parameters:
    
    startPosition - to compare against
    
    Returns:
    
    the length from the startPosition
  - readRemaining
```
public long readRemaining()
```
    Returns the remaining bytes that can be read.
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    How many more bytes can we read.
  - realReadRemaining
```
public long realReadRemaining()
```
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    how much can be safely read directly.
  - writeRemaining
```
public long writeRemaining()
```
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    How many more bytes can we written.
  - realWriteRemaining
```
public long realWriteRemaining()
```
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    writeRemaining with resize
  - readLimit
```
public long readLimit()
```
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    the highest offset or position allowed for this buffer.
  - writeLimit
```
public long writeLimit()
```
    Returns the write limit.
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    the write limit
  - addressForRead
```
public long addressForRead(long offset,
                           int buffer)
                    throws UnsupportedOperationException,
                           BufferUnderflowException,
                           IllegalStateException
```
    Throws:
    
    UnsupportedOperationException
    
    BufferUnderflowException
    
    IllegalStateException
  - byteOrder
```
public ByteOrder byteOrder()
```

Class SingletonEmptyByteStore

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

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

Field Detail

INSTANCE

Method Detail

reserve

release

releaseLast

refCount

tryReserve

reservedBy

writeByte

writeShort

writeInt

writeOrderedInt

writeLong

writeOrderedLong

writeFloat

writeDouble

writeVolatileByte

writeVolatileShort

writeVolatileInt

writeVolatileLong

write

write

write

readByte

peekUnsignedByte

readShort

readInt

readLong

readFloat

readDouble

readVolatileByte

readVolatileShort

readVolatileInt

readVolatileLong

isDirectMemory

copy

bytesForRead

capacity

underlyingObject

inside

inside

copyTo

nativeWrite

write8bit

write8bit

nativeRead

compareAndSwapInt

testAndSetInt

compareAndSwapLong

equalBytes

move

addressForRead

addressForWrite

addressForWritePosition

bytesForWrite

sharedMemory

zeroOut

isImmutableEmptyByteStore

toString

chars

codePoints

length

charAt

subSequence

hashCode

equals

start

readPosition