MappedBytesStore (OpenHFT/Chronicle-Bytes 2.24ea16 API)

java.lang.Object
- net.openhft.chronicle.core.io.AbstractReferenceCounted
- - net.openhft.chronicle.bytes.internal.AbstractBytesStore<NativeBytesStore<U>,U>
  - - net.openhft.chronicle.bytes.internal.NativeBytesStore<Void>
    - - net.openhft.chronicle.bytes.MappedBytesStore

All Implemented Interfaces:

CharSequence, BytesStore<NativeBytesStore<Void>,Void>, RandomDataInput, RandomDataOutput<NativeBytesStore<Void>>, net.openhft.chronicle.core.io.ReferenceCounted, net.openhft.chronicle.core.io.ReferenceCountedTracer, net.openhft.chronicle.core.io.ReferenceOwner, net.openhft.chronicle.core.io.SingleThreadedChecked
```
public class MappedBytesStore
extends NativeBytesStore<Void>
```
A BytesStore implementation that wraps memory-mapped data.
This class is intended for working with large files that can be read from and written to as if they were a part of the program's memory.
WARNING: This class assumes that the caller will correctly handle bounds checking. Incorrect handling can lead to IndexOutOfBoundsException. Misuse of this class can cause hard-to-diagnose memory access errors and data corruption.

Field Summary

Fields
Modifier and Type Field and Description

static @NotNull MappedBytesStoreFactory MAPPED_BYTES_STORE_FACTORY
Deprecated.

protected Runnable writeCheck
- Fields inherited from class net.openhft.chronicle.bytes.internal.NativeBytesStore
  address, limit, maximumLimit, memory
- Fields inherited from class net.openhft.chronicle.core.io.AbstractReferenceCounted
  referenceCounted, WARN_COUNT, WARN_NS
- Fields inherited from interface net.openhft.chronicle.bytes.RandomDataInput
  charToString
- Fields inherited from interface net.openhft.chronicle.core.io.ReferenceOwner
  INIT, TMP
- Fields inherited from interface net.openhft.chronicle.core.io.SingleThreadedChecked
  DISABLE_SINGLE_THREADED_CHECK

Fields
Modifier and Type	Field and Description
`static @NotNull MappedBytesStoreFactory`	`MAPPED_BYTES_STORE_FACTORY` Deprecated.
`protected Runnable`	`writeCheck`

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`MappedBytesStore(net.openhft.chronicle.core.io.ReferenceOwner owner, MappedFile mappedFile, long start, long address, long capacity, long safeCapacity)` Creates a new MappedBytesStore with the given parameters.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Default Methods
Modifier and Type	Method and Description
`default long`	`addressForRead(long offset, int buffer)` Retrieves the underlying memory address for reading.
`long`	`appendUtf8(long pos, char[] chars, int offset, int length)`
`default ByteOrder`	`byteOrder()` Retrieves the byte order used by the buffer.
`@NotNull Bytes<Void>`	`bytesForRead()` Returns a Bytes that wraps this ByteStore from the `start` to the `realCapacity`.
`@NotNull VanillaBytes<Void>`	`bytesForWrite()` Returns a Bytes that wraps this ByteStore from the `start` to the `realCapacity`.
`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.
`static MappedBytesStore`	`create(net.openhft.chronicle.core.io.ReferenceOwner owner, MappedFile mappedFile, long start, long address, long capacity, long safeCapacity)` Creates a new MappedBytesStore with the given parameters.
`boolean`	`inside(long offset)` Returns if a specified offset is inside this BytesStore limits.
`boolean`	`inside(long offset, long bufferSize)` Returns if a number of bytes starting from an offset are inside this ByteStore limits.
`default long`	`lengthWritten(long startPosition)` Calculates the length of data written from the given start position.
`FileLock`	`lock(long position, long size, boolean shared)` Acquires a lock on a region of the underlying file.
`void`	`nativeWrite(long address, long position, long size)` Expert-level method that copies data directly from native memory into this BytesStore.
`protected void`	`performRelease()` Sync the ByteStore if required.
`byte`	`readByte(long offset)` Reads a byte value from a specific offset.
`default long`	`readLimit()` If the resource is closed, the returned value is unspecified.
`long`	`readPosition()` Returns the read position.
`default long`	`realReadRemaining()` Calculates the number of bytes that can be safely read directly.
`default long`	`realWriteRemaining()` Calculates the number of bytes remaining that can be written from the current write position with resizing.
`long`	`safeLimit()`
`long`	`start()`
`SyncMode`	`syncMode()`
`void`	`syncMode(SyncMode syncMode)` Set the sync mode for this ByteStore
`void`	`syncUpTo(long position)` Synchronise from the last complete page up to this position.
`long`	`translate(long offset)`
`FileLock`	`tryLock(long position, long size, boolean shared)` Attempts to acquire a lock on a region of the underlying file.
`long`	`underlyingCapacity()` Fetch the capacity of the underlying file This can differ from the exposed capacity() of this bytes store (which has been page aligned)
`@NotNull MappedBytesStore`	`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)` Copies a segment from the provided ByteBuffer into this data output.
`@NotNull MappedBytesStore`	`write(long writeOffset, @NotNull RandomDataInput bytes, long readOffset, long length)` Copies a segment from the provided RandomDataInput into this data output.
`void`	`write0(long offsetInRDO, @NotNull RandomDataInput bytes, long offset, long length)`
`@NotNull MappedBytesStore`	`writeByte(long offset, byte i8)` Writes a byte at the specified non-negative offset.
`@NotNull MappedBytesStore`	`writeDouble(long offset, double d)` Writes a double-precision floating-point value at the specified non-negative offset.
`@NotNull MappedBytesStore`	`writeFloat(long offset, float f)` Writes a single-precision floating-point value at the specified non-negative offset.
`@NotNull MappedBytesStore`	`writeInt(long offset, int i32)` Writes an integer value at the specified non-negative offset.
`default long`	`writeLimit()` Retrieves the maximum writable position within the buffer.
`@NotNull MappedBytesStore`	`writeLong(long offset, long i64)` Writes a long integer value at the specified non-negative offset.
`@NotNull MappedBytesStore`	`writeOrderedInt(long offset, int i)` Performs a non-blocking write operation with a memory barrier to ensure order of stores.
`@NotNull MappedBytesStore`	`writeOrderedLong(long offset, long i)` Performs a non-blocking write operation with a memory barrier to ensure order of stores.
`default long`	`writePosition()` Returns the write position.
`@NotNull MappedBytesStore`	`writeShort(long offset, short i16)` Writes a short integer at the specified non-negative offset.
`@NotNull MappedBytesStore`	`writeVolatileByte(long offset, byte i8)` Writes a volatile byte at the specified non-negative offset.
`@NotNull MappedBytesStore`	`writeVolatileInt(long offset, int i32)` Writes a volatile integer at the specified non-negative offset.
`@NotNull MappedBytesStore`	`writeVolatileLong(long offset, long i64)` Writes a volatile long integer at the specified non-negative offset.
`@NotNull MappedBytesStore`	`writeVolatileShort(long offset, short i16)` Writes a volatile short at the specified non-negative offset.
`@NotNull MappedBytesStore`	`zeroOut(long start, long end)` Fills the BytesStore with zeros.

Methods inherited from class net.openhft.chronicle.bytes.internal.NativeBytesStore
addAndGetInt, addAndGetLong, addressForRead, addressForWrite, addressForWritePosition, appendAndReturnLength, backgroundPerformRelease, byteCheckSum, byteCheckSum, canReadDirect, capacity, copy, copyTo, copyToDirect, elasticByteBuffer, elasticByteBuffer, equals, fastHash, follow, from, from, hashCode, init, isDirectMemory, isEqual, lazyNativeBytesStoreWithFixedCapacity, move, nativeRead, nativeStore, nativeStoreWithFixedCapacity, peekUnsignedByte, read, read8bit, readDouble, readFloat, readIncompleteLong, readInt, readLong, readShort, readUnsignedByte, readVolatileByte, readVolatileInt, readVolatileLong, readVolatileShort, realCapacity, reverseBytesFrom, setAddress, sharedMemory, testAndSetInt, toString, toTemporaryDirectByteBuffer, underlyingObject, uninit, uninitialized, wrap, write8bit, write8bit

Methods inherited from class net.openhft.chronicle.bytes.internal.AbstractBytesStore
canReleaseInBackground, internalNumberBuffer, readRemaining, writeRemaining

Methods inherited from class net.openhft.chronicle.core.io.AbstractReferenceCounted
addReferenceChangeListener, assertReferencesReleased, clearUsedByThread, createdHere, disableReferenceTracing, enableReferenceTracing, refCount, referenceCountedUnmonitored, referenceId, release, releaseLast, removeReferenceChangeListener, reserve, reservedBy, reserveTransfer, singleThreadedCheckDisabled, singleThreadedCheckReset, threadSafetyCheck, throwExceptionIfNotReleased, throwExceptionIfReleased, tryReserve, unmonitor, warnAndReleaseIfNotReleased

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, addAndGetIntNotAtomic, addAndGetShortNotAtomic, addAndGetUnsignedByteNotAtomic, bytesStore, charAt, cipher, cipher, compareAndSwapDouble, compareAndSwapFloat, contentEquals, copyTo, empty, endsWith, equalBytes, forFields, from, from, hash, isClear, isEmpty, isImmutableEmptyByteStore, length, nativePointer, nativeStoreFrom, readWrite, startsWith, startsWith, subSequence, to8bitString, toDebugString, toDebugString, wrap, wrap, writeMaxInt, writeMaxLong

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

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

Methods inherited from interface net.openhft.chronicle.core.io.ReferenceCounted
addReferenceChangeListener, refCount, release, releaseLast, releaseLast, removeReferenceChangeListener, 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

Methods inherited from interface net.openhft.chronicle.core.io.ReferenceCountedTracer
onReleased

- Field Detail
  - MAPPED_BYTES_STORE_FACTORY
```
@Deprecated
 @NotNull
public static final @NotNull MappedBytesStoreFactory MAPPED_BYTES_STORE_FACTORY
```
    Deprecated.
  - writeCheck
```
protected final Runnable writeCheck
```
- Constructor Detail
  - MappedBytesStore
```
protected MappedBytesStore(net.openhft.chronicle.core.io.ReferenceOwner owner,
                           MappedFile mappedFile,
                           long start,
                           long address,
                           long capacity,
                           long safeCapacity)
                    throws IllegalStateException
```
    Creates a new MappedBytesStore with the given parameters.
    
    Parameters:
    
    owner - The owner of this MappedBytesStore.
    
    mappedFile - The MappedFile to be wrapped by this BytesStore.
    
    start - The start position within the MappedFile.
    
    address - The memory address of the mapped data.
    
    capacity - The capacity of the mapped data.
    
    safeCapacity - The safe capacity of the mapped data. Accessing data beyond the safe capacity might lead to a crash.
    
    Throws:
    
    IllegalStateException - If the MappedFile has already been released.
- Method Detail
  - create
```
public static MappedBytesStore create(net.openhft.chronicle.core.io.ReferenceOwner owner,
                                      MappedFile mappedFile,
                                      long start,
                                      long address,
                                      long capacity,
                                      long safeCapacity)
                               throws IllegalStateException
```
    Creates a new MappedBytesStore with the given parameters.
    
    Parameters:
    
    owner - The owner of this MappedBytesStore.
    
    mappedFile - The MappedFile to be wrapped by this BytesStore.
    
    start - The start position within the MappedFile.
    
    address - The memory address of the mapped data.
    
    capacity - The capacity of the mapped data.
    
    safeCapacity - The safe capacity of the mapped data. Accessing data beyond the safe capacity might lead to a crash.
    
    Returns:
    
    the MappedBytesStore
    
    Throws:
    
    IllegalStateException - If the MappedFile has already been released.
  - underlyingCapacity
```
public long underlyingCapacity()
```
    Fetch the capacity of the underlying file This can differ from the exposed capacity() of this bytes store (which has been page aligned)
    
    Returns:
    
    - capacity of the underlying file
  - 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.
    
    Returns:
    
    a Bytes that wraps this ByteStore
    
    Throws:
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - if this Bytes has been released
    
    IllegalStateException - if this Bytes is in an unusable state
  - bytesForWrite
```
@NotNull
public @NotNull VanillaBytes<Void> bytesForWrite()
                                                   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:
    
    bytesForWrite in interface BytesStore<NativeBytesStore<Void>,Void>
    
    Overrides:
    
    bytesForWrite in class NativeBytesStore<Void>
    
    Returns:
    
    a Bytes that wraps this BytesStore
    
    Throws:
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - if this Bytes has been released
    
    IllegalStateException - if this Bytes is in an unusable state
  - 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 for reading from. Note that it checks we are inside the BytesStore limits *without* including the overlap
    
    Parameters:
    
    offset - the specified offset to check
    
    Returns:
    
    true if offset is safe
  - inside
```
public boolean inside(long offset,
                      long bufferSize)
```
    Description copied from interface: BytesStore
    
    Returns if a number of bytes starting from an offset are inside this ByteStore limits.
    
    Parameters:
    
    offset - the starting index to check
    
    bufferSize - the number of bytes to be read/written
    
    Returns:
    
    true if the bytes between the offset and offset+buffer are inside the BytesStore
  - safeLimit
```
public long safeLimit()
```
    Specified by:
    
    safeLimit in interface BytesStore<NativeBytesStore<Void>,Void>
    
    Overrides:
    
    safeLimit in class NativeBytesStore<Void>
    
    Returns:
    
    how many bytes can be safely read, i.e. what is the real capacity of the underlying data.
  - readByte
```
public byte readByte(long offset)
```
    Description copied from interface: RandomDataInput
    
    Reads a byte value from a specific offset.
    
    Specified by:
    
    readByte in interface RandomDataInput
    
    Overrides:
    
    readByte in class NativeBytesStore<Void>
    
    Parameters:
    
    offset - the location from where the byte value is read.
    
    Returns:
    
    the read byte value.
  - writeOrderedInt
```
@NotNull
public @NotNull MappedBytesStore writeOrderedInt(long offset,
                                                          int i)
                                                   throws IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Performs a non-blocking write operation with a memory barrier to ensure order of stores. Writes an integer at the specified non-negative offset.
    
    Specified by:
    
    writeOrderedInt in interface RandomDataOutput<NativeBytesStore<Void>>
    
    Overrides:
    
    writeOrderedInt in class NativeBytesStore<Void>
    
    Parameters:
    
    offset - The non-negative position within the data stream to write the integer to.
    
    i - The integer value to write.
    
    Returns:
    
    Reference to the current instance, allowing for method chaining.
    
    Throws:
    
    IllegalStateException - if released
  - translate
```
public long translate(long offset)
```
    Overrides:
    
    translate in class NativeBytesStore<Void>
  - start
```
public long start()
```
    Overrides:
    
    start in class AbstractBytesStore<NativeBytesStore<Void>,Void>
    
    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.
    
    Overrides:
    
    readPosition in class AbstractBytesStore<NativeBytesStore<Void>,Void>
    
    Returns:
    
    position to read from.
  - lock
```
public FileLock lock(long position,
                     long size,
                     boolean shared)
              throws IOException
```
    Acquires a lock on a region of the underlying file. This method blocks until the lock has been acquired.
    
    Parameters:
    
    position - The starting byte position of the region to lock.
    
    size - The number of bytes to lock, starting from the position.
    
    shared - If true, the lock will be shared; otherwise, it will be exclusive.
    
    Returns:
    
    A FileLock representing the lock on the specified region.
    
    Throws:
    
    IOException - If an I/O error occurs while locking.
    
    See Also:
    
    for details on how the lock is acquired.
  - tryLock
```
public FileLock tryLock(long position,
                        long size,
                        boolean shared)
                 throws IOException
```
    Attempts to acquire a lock on a region of the underlying file. This method does not block and returns immediately, either with a lock or with null if the lock could not be acquired.
    
    Parameters:
    
    position - The starting byte position of the region to lock.
    
    size - The number of bytes to lock, starting from the position.
    
    shared - If true, the lock will be shared; otherwise, it will be exclusive.
    
    Returns:
    
    A FileLock representing the lock on the specified region or null if the lock could not be acquired.
    
    Throws:
    
    IOException - If an I/O error occurs while trying to lock.
    
    See Also:
    
    for details on how the lock is attempted.
  - zeroOut
```
@NotNull
public @NotNull MappedBytesStore zeroOut(long start,
                                                  long end)
```
    Description copied from interface: BytesStore
    
    Fills the BytesStore with zeros.
    
    Specified by:
    
    zeroOut in interface BytesStore<NativeBytesStore<Void>,Void>
    
    Specified by:
    
    zeroOut in interface RandomDataOutput<NativeBytesStore<Void>>
    
    Overrides:
    
    zeroOut in class NativeBytesStore<Void>
    
    Parameters:
    
    start - first byte inclusive
    
    end - last byte exclusive
    
    Returns:
    
    this
  - compareAndSwapInt
```
public boolean compareAndSwapInt(long offset,
                                 int expected,
                                 int value)
                          throws IllegalStateException
```
    Description copied from interface: RandomDataInput
    
    Perform a 32-bit CAS at a given offset.
    
    Specified by:
    
    compareAndSwapInt in interface BytesStore<NativeBytesStore<Void>,Void>
    
    Specified by:
    
    compareAndSwapInt in interface RandomDataInput
    
    Specified by:
    
    compareAndSwapInt in interface RandomDataOutput<NativeBytesStore<Void>>
    
    Overrides:
    
    compareAndSwapInt in class NativeBytesStore<Void>
    
    Parameters:
    
    offset - to perform CAS
    
    expected - value
    
    value - to set
    
    Returns:
    
    true, if successful.
    
    Throws:
    
    IllegalStateException - if released
  - compareAndSwapLong
```
public boolean compareAndSwapLong(long offset,
                                  long expected,
                                  long value)
                           throws IllegalStateException
```
    Description copied from interface: RandomDataInput
    
    Perform a 64-bit CAS at a given offset.
    
    Specified by:
    
    compareAndSwapLong in interface BytesStore<NativeBytesStore<Void>,Void>
    
    Specified by:
    
    compareAndSwapLong in interface RandomDataInput
    
    Specified by:
    
    compareAndSwapLong in interface RandomDataOutput<NativeBytesStore<Void>>
    
    Overrides:
    
    compareAndSwapLong in class NativeBytesStore<Void>
    
    Parameters:
    
    offset - to perform CAS
    
    expected - value
    
    value - to set
    
    Returns:
    
    true, if successful.
    
    Throws:
    
    IllegalStateException - if released
  - writeByte
```
@NotNull
public @NotNull MappedBytesStore writeByte(long offset,
                                                    byte i8)
                                             throws IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Writes a byte at the specified non-negative offset.
    
    Specified by:
    
    writeByte in interface RandomDataOutput<NativeBytesStore<Void>>
    
    Overrides:
    
    writeByte in class NativeBytesStore<Void>
    
    Parameters:
    
    offset - The non-negative position within the data stream to write the byte to.
    
    i8 - The byte value to write.
    
    Returns:
    
    Reference to the current instance, allowing for method chaining.
    
    Throws:
    
    IllegalStateException - if released
  - writeShort
```
@NotNull
public @NotNull MappedBytesStore writeShort(long offset,
                                                     short i16)
                                              throws IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Writes a short integer at the specified non-negative offset.
    
    Specified by:
    
    writeShort in interface RandomDataOutput<NativeBytesStore<Void>>
    
    Overrides:
    
    writeShort in class NativeBytesStore<Void>
    
    Parameters:
    
    offset - The non-negative position within the data stream to write the short integer to.
    
    i16 - The short integer value to write.
    
    Returns:
    
    Reference to the current instance, allowing for method chaining.
    
    Throws:
    
    IllegalStateException - if released
  - writeInt
```
@NotNull
public @NotNull MappedBytesStore writeInt(long offset,
                                                   int i32)
                                            throws IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Writes an integer value at the specified non-negative offset.
    
    Specified by:
    
    writeInt in interface RandomDataOutput<NativeBytesStore<Void>>
    
    Overrides:
    
    writeInt in class NativeBytesStore<Void>
    
    Parameters:
    
    offset - The non-negative position within the data stream to write the integer to.
    
    i32 - The integer value to write.
    
    Returns:
    
    Reference to the current instance, allowing for method chaining.
    
    Throws:
    
    IllegalStateException - if released
  - writeLong
```
@NotNull
public @NotNull MappedBytesStore writeLong(long offset,
                                                    long i64)
                                             throws IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Writes a long integer value at the specified non-negative offset.
    
    Specified by:
    
    writeLong in interface RandomDataOutput<NativeBytesStore<Void>>
    
    Overrides:
    
    writeLong in class NativeBytesStore<Void>
    
    Parameters:
    
    offset - The non-negative position within the data stream to write the long integer to.
    
    i64 - The long integer value to write.
    
    Returns:
    
    Reference to the current instance, allowing for method chaining.
    
    Throws:
    
    IllegalStateException - if released
  - writeOrderedLong
```
@NotNull
public @NotNull MappedBytesStore writeOrderedLong(long offset,
                                                           long i)
                                                    throws IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Performs a non-blocking write operation with a memory barrier to ensure order of stores. Writes a long integer at the specified non-negative offset.
    
    Specified by:
    
    writeOrderedLong in interface RandomDataOutput<NativeBytesStore<Void>>
    
    Overrides:
    
    writeOrderedLong in class NativeBytesStore<Void>
    
    Parameters:
    
    offset - The non-negative position within the data stream to write the long integer to.
    
    i - The long integer value to write.
    
    Returns:
    
    Reference to the current instance, allowing for method chaining.
    
    Throws:
    
    IllegalStateException - if released
  - writeFloat
```
@NotNull
public @NotNull MappedBytesStore writeFloat(long offset,
                                                     float f)
                                              throws IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Writes a single-precision floating-point value at the specified non-negative offset.
    
    Specified by:
    
    writeFloat in interface RandomDataOutput<NativeBytesStore<Void>>
    
    Overrides:
    
    writeFloat in class NativeBytesStore<Void>
    
    Parameters:
    
    offset - The non-negative position within the data stream to write the float to.
    
    f - The float value to write.
    
    Returns:
    
    Reference to the current instance, allowing for method chaining.
    
    Throws:
    
    IllegalStateException - if released
  - writeDouble
```
@NotNull
public @NotNull MappedBytesStore writeDouble(long offset,
                                                      double d)
                                               throws IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Writes a double-precision floating-point value at the specified non-negative offset.
    
    Specified by:
    
    writeDouble in interface RandomDataOutput<NativeBytesStore<Void>>
    
    Overrides:
    
    writeDouble in class NativeBytesStore<Void>
    
    Parameters:
    
    offset - The non-negative position within the data stream to write the double to.
    
    d - The double value to write.
    
    Returns:
    
    Reference to the current instance, allowing for method chaining.
    
    Throws:
    
    IllegalStateException - if released
  - writeVolatileByte
```
@NotNull
public @NotNull MappedBytesStore writeVolatileByte(long offset,
                                                            byte i8)
                                                     throws IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Writes a volatile byte at the specified non-negative offset. The write is volatile, ensuring it is not cached and instantly visible to all threads.
    
    Specified by:
    
    writeVolatileByte in interface RandomDataOutput<NativeBytesStore<Void>>
    
    Overrides:
    
    writeVolatileByte in class NativeBytesStore<Void>
    
    Parameters:
    
    offset - The non-negative position within the data stream to write the byte to.
    
    i8 - The byte value to write.
    
    Returns:
    
    Reference to the current instance, allowing for method chaining.
    
    Throws:
    
    IllegalStateException - if released
  - writeVolatileShort
```
@NotNull
public @NotNull MappedBytesStore writeVolatileShort(long offset,
                                                             short i16)
                                                      throws IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Writes a volatile short at the specified non-negative offset. The write is volatile, ensuring it is not cached and instantly visible to all threads.
    
    Specified by:
    
    writeVolatileShort in interface RandomDataOutput<NativeBytesStore<Void>>
    
    Overrides:
    
    writeVolatileShort in class NativeBytesStore<Void>
    
    Parameters:
    
    offset - The non-negative position within the data stream to write the short to.
    
    i16 - The short value to write.
    
    Returns:
    
    Reference to the current instance, allowing for method chaining.
    
    Throws:
    
    IllegalStateException - if released
  - writeVolatileInt
```
@NotNull
public @NotNull MappedBytesStore writeVolatileInt(long offset,
                                                           int i32)
                                                    throws IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Writes a volatile integer at the specified non-negative offset. The write is volatile, ensuring it is not cached and instantly visible to all threads.
    
    Specified by:
    
    writeVolatileInt in interface RandomDataOutput<NativeBytesStore<Void>>
    
    Overrides:
    
    writeVolatileInt in class NativeBytesStore<Void>
    
    Parameters:
    
    offset - The non-negative position within the data stream to write the integer to.
    
    i32 - The integer value to write.
    
    Returns:
    
    Reference to the current instance, allowing for method chaining.
    
    Throws:
    
    IllegalStateException - if released
  - writeVolatileLong
```
@NotNull
public @NotNull MappedBytesStore writeVolatileLong(long offset,
                                                            long i64)
                                                     throws IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Writes a volatile long integer at the specified non-negative offset. The write is volatile, ensuring it is not cached and instantly visible to all threads.
    
    Specified by:
    
    writeVolatileLong in interface RandomDataOutput<NativeBytesStore<Void>>
    
    Overrides:
    
    writeVolatileLong in class NativeBytesStore<Void>
    
    Parameters:
    
    offset - The non-negative position within the data stream to write the long integer to.
    
    i64 - The long integer value to write.
    
    Returns:
    
    Reference to the current instance, allowing for method chaining.
    
    Throws:
    
    IllegalStateException - if released
  - write
```
@NotNull
public @NotNull MappedBytesStore write(long offsetInRDO,
                                                byte[] byteArray,
                                                int offset,
                                                int length)
                                         throws IllegalStateException
```
    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<NativeBytesStore<Void>>
    
    Overrides:
    
    write in class NativeBytesStore<Void>
    
    Parameters:
    
    offsetInRDO - the non-negative offset within the data output where the segment should be written.
    
    byteArray - the byte array containing the segment to be written.
    
    offset - the non-negative offset within the byte array where the segment begins.
    
    length - the non-negative length of the segment.
    
    Returns:
    
    a reference to this instance.
    
    Throws:
    
    IllegalStateException - if this data output has been previously released.
  - write
```
public void write(long offsetInRDO,
                  @NotNull
                  @NotNull ByteBuffer bytes,
                  int offset,
                  int length)
           throws IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Copies a segment from the provided ByteBuffer into this data output.
    Does not update cursors e.g. writePosition()
    
    Specified by:
    
    write in interface RandomDataOutput<NativeBytesStore<Void>>
    
    Overrides:
    
    write in class NativeBytesStore<Void>
    
    Parameters:
    
    offsetInRDO - the non-negative offset within the data output where the segment should be written.
    
    bytes - the ByteBuffer containing the segment to be written.
    
    offset - the non-negative offset within the ByteBuffer where the segment begins.
    
    length - the non-negative length of the segment.
    
    Throws:
    
    IllegalStateException - if this data output has been previously released.
  - write
```
@NotNull
public @NotNull MappedBytesStore write(long writeOffset,
                                                @NotNull
                                                @NotNull RandomDataInput bytes,
                                                long readOffset,
                                                long length)
                                         throws BufferOverflowException,
                                                BufferUnderflowException,
                                                IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Copies a segment from the provided RandomDataInput into this data output. This operation does not update the writePosition() of this output nor the RandomCommon.readPosition() of the input.
    
    Specified by:
    
    write in interface RandomDataOutput<NativeBytesStore<Void>>
    
    Overrides:
    
    write in class NativeBytesStore<Void>
    
    Parameters:
    
    writeOffset - the non-negative offset within this data output where the segment should be written.
    
    bytes - the RandomDataInput source containing the segment to be written.
    
    readOffset - the non-negative offset within the source where the segment begins.
    
    length - the non-negative length of the segment.
    
    Returns:
    
    a reference to this instance.
    
    Throws:
    
    BufferOverflowException - if the capacity of this data output was exceeded.
    
    BufferUnderflowException - if the source does not have enough data to fill the length.
    
    IllegalStateException - if this data output has been previously released.
  - write0
```
public void write0(long offsetInRDO,
                   @NotNull
                   @NotNull RandomDataInput bytes,
                   long offset,
                   long length)
            throws IllegalStateException
```
    Overrides:
    
    write0 in class NativeBytesStore<Void>
    
    Throws:
    
    IllegalStateException
  - nativeWrite
```
public void nativeWrite(long address,
                        long position,
                        long size)
                 throws IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Expert-level method that copies data directly from native memory into this BytesStore.
    
    Specified by:
    
    nativeWrite in interface RandomDataOutput<NativeBytesStore<Void>>
    
    Overrides:
    
    nativeWrite in class NativeBytesStore<Void>
    
    Parameters:
    
    address - the address in the native memory from where data should be copied.
    
    position - the position in the BytesStore where data should be written.
    
    size - the size of the data, in bytes, to be copied from the native memory.
    
    Throws:
    
    IllegalStateException - if this BytesStore has been previously released.
  - appendUtf8
```
public long appendUtf8(long pos,
                       char[] chars,
                       int offset,
                       int length)
                throws IllegalStateException
```
    Overrides:
    
    appendUtf8 in class NativeBytesStore<Void>
    
    Throws:
    
    IllegalStateException
  - performRelease
```
protected void performRelease()
```
    Sync the ByteStore if required.
    
    Overrides:
    
    performRelease in class NativeBytesStore<Void>
  - syncMode
```
public SyncMode syncMode()
```
    Returns:
    
    the sync mode for this ByteStore
  - syncMode
```
public void syncMode(SyncMode syncMode)
```
    Set the sync mode for this ByteStore
    
    Parameters:
    
    syncMode - to use
  - syncUpTo
```
public void syncUpTo(long position)
```
    Synchronise from the last complete page up to this position.
    
    Parameters:
    
    position - to sync with the syncMode()
  - 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)
```
    Calculates the length of data written from the given start position.
    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 - The position to calculate the length from.
    
    Returns:
    
    The length of data written from the given start position.
  - realReadRemaining
```
public long realReadRemaining()
```
    Calculates the number of bytes that can be safely read directly.
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    The number of bytes that can be safely read directly.
  - realWriteRemaining
```
public long realWriteRemaining()
```
    Calculates the number of bytes remaining that can be written from the current write position with resizing.
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    The number of bytes that can still be written with resizing.
  - 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()
```
    Retrieves the maximum writable position within the buffer.
    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
```
    Retrieves the underlying memory address for reading. This is for expert users only.
    
    Parameters:
    
    offset - The offset within this buffer.
    
    buffer - The buffer index.
    
    Returns:
    
    The underlying memory address for reading at the specified offset.
    
    Throws:
    
    UnsupportedOperationException - if the underlying buffer is on the heap.
    
    BufferUnderflowException - if the offset is before the start or after the capacity.
    
    IllegalStateException - if the buffer has been closed.
  - byteOrder
```
public ByteOrder byteOrder()
```
    Retrieves the byte order used by the buffer.
    
    Returns:
    
    The byte order used by the buffer.

Class MappedBytesStore

Field Summary

Fields inherited from class net.openhft.chronicle.bytes.internal.NativeBytesStore

Fields inherited from class net.openhft.chronicle.core.io.AbstractReferenceCounted

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

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

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

Constructor Summary

Method Summary

Methods inherited from class net.openhft.chronicle.bytes.internal.NativeBytesStore

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

Methods inherited from class net.openhft.chronicle.core.io.AbstractReferenceCounted

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

Methods inherited from interface java.lang.CharSequence

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

Field Detail

MAPPED_BYTES_STORE_FACTORY

writeCheck

Constructor Detail

MappedBytesStore

Method Detail

create

underlyingCapacity

bytesForRead

bytesForWrite

inside

inside

safeLimit

readByte

writeOrderedInt

translate

start

readPosition

lock

tryLock

zeroOut

compareAndSwapInt

compareAndSwapLong

writeByte

writeShort

writeInt

writeLong

writeOrderedLong

writeFloat

writeDouble

writeVolatileByte

writeVolatileShort

writeVolatileInt

writeVolatileLong

write

write

write

write0

nativeWrite

appendUtf8

performRelease

syncMode

syncMode

syncUpTo

writePosition

lengthWritten

realReadRemaining

realWriteRemaining

readLimit

writeLimit

addressForRead

byteOrder