HeapBytesStore (OpenHFT/Chronicle-Bytes 2.24ea16 API)

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

Type Parameters:

U - Underlying type

All Implemented Interfaces:

CharSequence, BytesStore<HeapBytesStore,U>, RandomDataInput, RandomDataOutput<HeapBytesStore>, 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 HeapBytesStore
extends AbstractBytesStore<HeapBytesStore,U>
```
Wrapper for Heap ByteBuffers and arrays.

Field Summary
- 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

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Default Methods
Modifier and Type	Method and Description
`long`	`addressForRead(long offset)` Retrieves the underlying memory address for reading.
`default long`	`addressForRead(long offset, int buffer)` Retrieves the underlying memory address for reading.
`long`	`addressForWrite(long offset)` Retrieves the underlying memory address for writing.
`long`	`addressForWritePosition()` Retrieves the underlying memory address for writing at the current write position.
`long`	`appendAndReturnLength(long writePosition, boolean negative, long mantissa, int exponent, boolean append0)`
`default ByteOrder`	`byteOrder()` Retrieves the byte order used by the buffer.
`long`	`capacity()` Provides the maximum limit that can be set for the ByteStore.
`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 BytesStore<HeapBytesStore<U>,U>`	`copy()` Creates and returns a copy of this BytesStore.
`boolean`	`equals(Object obj)`
`static <T> HeapBytesStore<T>`	`forFields(Object o, String groupName, int padding)` Provides a BytesStore that allows access to a group of fields in a given object.
`int`	`hashCode()`
`boolean`	`isDirectMemory()` Checks if this BytesStore uses direct memory.
`default long`	`lengthWritten(long startPosition)` Calculates the length of data written from the given start position.
`void`	`move(long from, long to, long length)` Moves a sequence of bytes within this BytesStore from the source to destination index.
`void`	`nativeRead(long position, long address, long size)` Expert-level method for transferring data from this byte source to native memory.
`void`	`nativeWrite(long address, long position, long size)` Expert-level method that copies data directly from native memory into this BytesStore.
`protected void`	`performRelease()`
`long`	`read(long offsetInRDI, byte[] bytes, int offset, int length)` Reads a sequence of bytes from the specified offset into a byte array.
`byte`	`readByte(long offset)` Reads a byte value from a specific offset.
`double`	`readDouble(long offset)` Reads a 64-bit floating point value from a specified offset.
`float`	`readFloat(long offset)` Reads a 32-bit floating point value from a specified offset.
`int`	`readInt(long offset)` Reads a 32-bit integer value from a specific offset.
`default long`	`readLimit()` If the resource is closed, the returned value is unspecified.
`long`	`readLong(long offset)` Reads a 64-bit long value from a specific offset.
`short`	`readShort(long offset)` Reads a short value from a specific offset.
`byte`	`readVolatileByte(long offset)` Reads a volatile 8-bit byte value from a specified offset.
`int`	`readVolatileInt(long offset)` Reads a volatile 32-bit integer value from a specified offset.
`long`	`readVolatileLong(long offset)` Reads a volatile 64-bit long value from a specified offset.
`short`	`readVolatileShort(long offset)` Reads a volatile 16-bit short value from a specified offset.
`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.
`protected void`	`reverseBytesFrom(long start, long end)`
`boolean`	`sharedMemory()` Checks if the Bytes use shared memory.
`void`	`testAndSetInt(long offset, int expected, int value)` Tests if the current value at the specified offset equals the expected value and, if so, sets it to the provided value.
`@NotNull String`	`toString()`
`U`	`underlyingObject()`
`static @NotNull HeapBytesStore<byte[]>`	`wrap(byte[] byteArray)` Wraps a byte array into a BytesStore.
`static @NotNull HeapBytesStore<ByteBuffer>`	`wrap(@NotNull ByteBuffer bb)` Wraps a ByteBuffer into a BytesStore.
`@NotNull HeapBytesStore<U>`	`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 HeapBytesStore<U>`	`write(long writeOffset, @NotNull RandomDataInput bytes, long readOffset, long length)` Copies a segment from the provided RandomDataInput into this data output.
`long`	`write8bit(long position, @NotNull BytesStore bs)` Writes a BytesStore instance to this RandomDataOutput at the given position.
`long`	`write8bit(long position, @NotNull String s, int start, int length)` Writes a portion of a string to this RandomDataOutput at the given position.
`@NotNull HeapBytesStore<U>`	`writeByte(long offset, byte b)` Writes a byte at the specified non-negative offset.
`@NotNull HeapBytesStore<U>`	`writeDouble(long offset, double d)` Writes a double-precision floating-point value at the specified non-negative offset.
`@NotNull HeapBytesStore<U>`	`writeFloat(long offset, float f)` Writes a single-precision floating-point value at the specified non-negative offset.
`@NotNull HeapBytesStore<U>`	`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 HeapBytesStore<U>`	`writeLong(long offset, long i64)` Writes a long integer value at the specified non-negative offset.
`@NotNull HeapBytesStore<U>`	`writeOrderedInt(long offset, int i32)` Performs a non-blocking write operation with a memory barrier to ensure order of stores.
`@NotNull HeapBytesStore<U>`	`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 HeapBytesStore<U>`	`writeShort(long offset, short i16)` Writes a short integer at the specified non-negative offset.
`@NotNull HeapBytesStore<U>`	`writeVolatileByte(long offset, byte i8)` Writes a volatile byte at the specified non-negative offset.
`@NotNull HeapBytesStore<U>`	`writeVolatileInt(long offset, int i32)` Writes a volatile integer at the specified non-negative offset.
`@NotNull HeapBytesStore<U>`	`writeVolatileLong(long offset, long i64)` Writes a volatile long integer at the specified non-negative offset.
`@NotNull HeapBytesStore<U>`	`writeVolatileShort(long offset, short i16)` Writes a volatile short at the specified non-negative offset.

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

Methods inherited from class net.openhft.chronicle.core.io.AbstractReferenceCounted
addReferenceChangeListener, assertReferencesReleased, backgroundPerformRelease, 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, addAndGetInt, addAndGetIntNotAtomic, addAndGetLong, addAndGetShortNotAtomic, addAndGetUnsignedByteNotAtomic, byteCheckSum, byteCheckSum, bytesForRead, bytesForWrite, bytesStore, charAt, cipher, cipher, compareAndSwapDouble, compareAndSwapFloat, contentEquals, copyTo, copyTo, elasticByteBuffer, empty, endsWith, equalBytes, follow, from, from, from, hash, inside, inside, isClear, isEmpty, isEqual, isImmutableEmptyByteStore, lazyNativeBytesStoreWithFixedCapacity, length, nativePointer, nativeStore, nativeStoreFrom, nativeStoreWithFixedCapacity, readWrite, realCapacity, safeLimit, startsWith, startsWith, subSequence, to8bitString, toDebugString, toDebugString, wrap, writeMaxInt, writeMaxLong, zeroOut

Methods inherited from interface net.openhft.chronicle.bytes.RandomDataInput
canReadDirect, canReadDirect, compareUtf8, copyTo, copyTo, createCharToString, fastHash, findByte, parseLong, peekVolatileInt, printable, 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
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

- Method Detail
 - forFields
```
public static <T> HeapBytesStore<T> forFields(Object o,
 String groupName,
 int padding)
```
 Description copied from interface: BytesStore
 
 Provides a BytesStore that allows access to a group of fields in a given object.
 
 Parameters:
 
 o - the object that contains the fields
 
 groupName - the group name of the fields
 
 padding - the padding to be used
 
 Returns:
 
 a BytesStore which points to the fields
 - wrap
```
@NotNull
public static @NotNull HeapBytesStore<byte[]> wrap(byte[] byteArray)
```
 Description copied from interface: BytesStore
 
 Wraps a byte array into a BytesStore. There will be only one copy in memory.
 
 Parameters:
 
 byteArray - the byte array to be wrapped
 
 Returns:
 
 a BytesStore that contains the bytes from the array
 - wrap
```
@NotNull
public static @NotNull HeapBytesStore<ByteBuffer> wrap(@NotNull
 @NotNull ByteBuffer bb)
```
 Description copied from interface: BytesStore
 
 Wraps a ByteBuffer into a BytesStore. The ByteBuffer can be either on heap or off heap. When the resulting BytesStore is closed, the direct ByteBuffer will be deallocated and should not be used anymore.
 
 Parameters:
 
 bb - the ByteBuffer to be wrapped
 
 Returns:
 
 a BytesStore that contains the bytes from the ByteBuffer
 
 See Also:
 
 BytesStore.follow(ByteBuffer)
 - isDirectMemory
```
public boolean isDirectMemory()
```
 Description copied from interface: BytesStore
 
 Checks if this BytesStore uses direct memory.
 
 Returns:
 
 true if it uses direct memory, false otherwise
 - move
```
public void move(long from,
 long to,
 long length)
 throws BufferUnderflowException,
 ArithmeticException
```
 Description copied from interface: BytesStore
 
 Moves a sequence of bytes within this BytesStore from the source to destination index.
 
 Parameters:
 
 from - the index of the first byte to be moved
 
 to - the index where the first byte should be moved to
 
 length - the number of bytes to be moved
 
 Throws:
 
 BufferUnderflowException - if there's not enough data to be moved
 
 ArithmeticException - if the move would result in an index overflow
 - toString
```
@NotNull
public @NotNull String toString()
```
 Specified by:
 
 toString in interface CharSequence
 
 Overrides:
 
 toString in class net.openhft.chronicle.core.io.AbstractReferenceCounted
 - copy
```
@NotNull
public @NotNull BytesStore<HeapBytesStore,U> copy()
```
 Description copied from interface: BytesStore
 
 Creates and returns a copy of this BytesStore.
 
 Returns:
 
 a new instance of BytesStore that is a copy of this BytesStore
 - performRelease
```
protected void performRelease()
```
 Specified by:
 
 performRelease in class net.openhft.chronicle.core.io.AbstractReferenceCounted
 - capacity
```
public long capacity()
```
 Description copied from interface: BytesStore
 
 Provides the maximum limit that can be set for the ByteStore.
 
 Returns:
 
 the maximum capacity of the ByteStore
 - underlyingObject
```
public U underlyingObject()
```
 Returns:
 
 the underlying object being wrapped, if there is one, or null if not.
 - compareAndSwapInt
```
public boolean compareAndSwapInt(long offset,
 int expected,
 int value)
```
 Description copied from interface: RandomDataInput
 
 Perform a 32-bit CAS at a given offset.
 
 Parameters:
 
 offset - to perform CAS
 
 expected - value
 
 value - to set
 
 Returns:
 
 true, if successful.
 - testAndSetInt
```
public void testAndSetInt(long offset,
 int expected,
 int value)
 throws IllegalStateException
```
 Description copied from interface: RandomDataOutput
 
 Tests if the current value at the specified offset equals the expected value and, if so, sets it to the provided value.
 
 Parameters:
 
 offset - the offset at which to perform the test-and-set operation.
 
 expected - the expected current value.
 
 value - the new value to set if the current value matches the expected value.
 
 Throws:
 
 IllegalStateException - if this RandomDataOutput has been previously released.
 - compareAndSwapLong
```
public boolean compareAndSwapLong(long offset,
 long expected,
 long value)
```
 Description copied from interface: RandomDataInput
 
 Perform a 64-bit CAS at a given offset.
 
 Parameters:
 
 offset - to perform CAS
 
 expected - value
 
 value - to set
 
 Returns:
 
 true, if successful.
 - read
```
public long read(long offsetInRDI,
 byte[] bytes,
 int offset,
 int length)
```
 Description copied from interface: RandomDataInput
 
 Reads a sequence of bytes from the specified offset into a byte array.
 
 Parameters:
 
 offsetInRDI - the offset in the byte sequence from which to start reading.
 
 bytes - the byte array into which the data is read.
 
 offset - the start offset in the byte array at which the data is written.
 
 length - the maximum number of bytes to read.
 
 Returns:
 
 the actual number of bytes read into the byte array.
 - readByte
```
public byte readByte(long offset)
 throws BufferUnderflowException
```
 Description copied from interface: RandomDataInput
 
 Reads a byte value from a specific offset.
 
 Parameters:
 
 offset - the location from where the byte value is read.
 
 Returns:
 
 the read byte value.
 
 Throws:
 
 BufferUnderflowException - if the offset is outside the bounds of the byte source.
 - readShort
```
public short readShort(long offset)
 throws BufferUnderflowException
```
 Description copied from interface: RandomDataInput
 
 Reads a short value from a specific offset.
 
 Parameters:
 
 offset - the location from where the short value is read.
 
 Returns:
 
 the read short value.
 
 Throws:
 
 BufferUnderflowException - if the offset is outside the bounds of the byte source.
 - readInt
```
public int readInt(long offset)
 throws BufferUnderflowException
```
 Description copied from interface: RandomDataInput
 
 Reads a 32-bit integer value from a specific offset.
 
 Parameters:
 
 offset - the location from where the 32-bit integer value is read.
 
 Returns:
 
 the read int value.
 
 Throws:
 
 BufferUnderflowException - if the offset is outside the bounds of the byte source.
 - readLong
```
public long readLong(long offset)
 throws BufferUnderflowException
```
 Description copied from interface: RandomDataInput
 
 Reads a 64-bit long value from a specific offset.
 
 Parameters:
 
 offset - the location from where the long value is read.
 
 Returns:
 
 the read long value.
 
 Throws:
 
 BufferUnderflowException - if the offset is outside the bounds of the byte source.
 - readFloat
```
public float readFloat(long offset)
 throws BufferUnderflowException
```
 Description copied from interface: RandomDataInput
 
 Reads a 32-bit floating point value from a specified offset.
 
 Parameters:
 
 offset - the location from where the float value is read.
 
 Returns:
 
 the read float value.
 
 Throws:
 
 BufferUnderflowException - if the offset is beyond the limits of the byte source.
 - readDouble
```
public double readDouble(long offset)
 throws BufferUnderflowException
```
 Description copied from interface: RandomDataInput
 
 Reads a 64-bit floating point value from a specified offset.
 
 Parameters:
 
 offset - the location from where the double value is read.
 
 Returns:
 
 the read double value.
 
 Throws:
 
 BufferUnderflowException - if the offset is beyond the limits of the byte source.
 - readVolatileByte
```
public byte readVolatileByte(long offset)
 throws BufferUnderflowException
```
 Description copied from interface: RandomDataInput
 
 Reads a volatile 8-bit byte value from a specified offset. This operation includes a memory barrier that prevents reordering of instructions before and after it.
 
 Parameters:
 
 offset - the location from where the byte value is read.
 
 Returns:
 
 the volatile byte value.
 
 Throws:
 
 BufferUnderflowException - if the offset is beyond the limits of the byte source.
 - readVolatileShort
```
public short readVolatileShort(long offset)
 throws BufferUnderflowException
```
 Description copied from interface: RandomDataInput
 
 Reads a volatile 16-bit short value from a specified offset. This operation includes a memory barrier that prevents reordering of instructions before and after it.
 
 Parameters:
 
 offset - the location from where the short value is read.
 
 Returns:
 
 the volatile short value.
 
 Throws:
 
 BufferUnderflowException - if the offset is beyond the limits of the byte source.
 - readVolatileInt
```
public int readVolatileInt(long offset)
 throws BufferUnderflowException
```
 Description copied from interface: RandomDataInput
 
 Reads a volatile 32-bit integer value from a specified offset. This operation includes a memory barrier that prevents reordering of instructions before and after it.
 
 Parameters:
 
 offset - the location from where the int value is read.
 
 Returns:
 
 the volatile int value.
 
 Throws:
 
 BufferUnderflowException - if the offset is beyond the limits of the byte source.
 - readVolatileLong
```
public long readVolatileLong(long offset)
 throws BufferUnderflowException
```
 Description copied from interface: RandomDataInput
 
 Reads a volatile 64-bit long value from a specified offset. This operation includes a memory barrier that prevents reordering of instructions before and after it.
 
 Parameters:
 
 offset - the location from where the long value is read.
 
 Returns:
 
 the volatile long value.
 
 Throws:
 
 BufferUnderflowException - if the offset is beyond the limits of the byte source.
 - write8bit
```
public long write8bit(long position,
 @NotNull
 @NotNull BytesStore bs)
```
 Description copied from interface: RandomDataOutput
 
 Writes a BytesStore instance to this RandomDataOutput at the given position. The length of the BytesStore content is encoded using a stop bit encoding scheme.
 
 Parameters:
 
 position - the position at which the BytesStore content should be written.
 
 bs - the BytesStore instance to write.
 
 Returns:
 
 the offset after the BytesStore has been written.
 - write8bit
```
public long write8bit(long position,
 @NotNull
 @NotNull String s,
 int start,
 int length)
```
 Description copied from interface: RandomDataOutput
 
 Writes a portion of a string to this RandomDataOutput at the given position. The length of the string is encoded using a stop bit encoding scheme.
 
 Parameters:
 
 position - the position at which the string should be written.
 
 s - the string to write.
 
 start - the starting index from where characters are to be taken from the string.
 
 length - the number of characters to be written from the string.
 
 Returns:
 
 the offset after the string has been written.
 - writeByte
```
@NotNull
public @NotNull HeapBytesStore writeByte(long offset,
 byte b)
 throws BufferOverflowException
```
 Description copied from interface: RandomDataOutput
 
 Writes a byte at the specified non-negative offset.
 
 Parameters:
 
 offset - The non-negative position within the data stream to write the byte to.
 
 b - The byte value to write.
 
 Returns:
 
 Reference to the current instance, allowing for method chaining.
 
 Throws:
 
 BufferOverflowException - If the specified offset exceeds the available capacity.
 - writeShort
```
@NotNull
public @NotNull HeapBytesStore writeShort(long offset,
 short i16)
 throws BufferOverflowException
```
 Description copied from interface: RandomDataOutput
 
 Writes a short integer at the specified non-negative offset.
 
 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:
 
 BufferOverflowException - If the specified offset exceeds the available capacity.
 - writeInt
```
@NotNull
public @NotNull HeapBytesStore writeInt(long offset,
 int i32)
 throws BufferOverflowException
```
 Description copied from interface: RandomDataOutput
 
 Writes an integer value at the specified non-negative offset.
 
 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:
 
 BufferOverflowException - If the specified offset exceeds the available capacity.
 - writeOrderedInt
```
@NotNull
public @NotNull HeapBytesStore writeOrderedInt(long offset,
 int i32)
 throws BufferOverflowException
```
 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.
 
 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:
 
 BufferOverflowException - If the specified offset exceeds the available capacity.
 - writeLong
```
@NotNull
public @NotNull HeapBytesStore writeLong(long offset,
 long i64)
 throws BufferOverflowException
```
 Description copied from interface: RandomDataOutput
 
 Writes a long integer value at the specified non-negative offset.
 
 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:
 
 BufferOverflowException - If the specified offset exceeds the available capacity.
 - writeOrderedLong
```
@NotNull
public @NotNull HeapBytesStore writeOrderedLong(long offset,
 long i)
 throws BufferOverflowException
```
 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.
 
 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:
 
 BufferOverflowException - If the specified offset exceeds the available capacity.
 - writeFloat
```
@NotNull
public @NotNull HeapBytesStore writeFloat(long offset,
 float f)
 throws BufferOverflowException
```
 Description copied from interface: RandomDataOutput
 
 Writes a single-precision floating-point value at the specified non-negative offset.
 
 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:
 
 BufferOverflowException - If the specified offset exceeds the available capacity.
 - writeDouble
```
@NotNull
public @NotNull HeapBytesStore writeDouble(long offset,
 double d)
 throws BufferOverflowException
```
 Description copied from interface: RandomDataOutput
 
 Writes a double-precision floating-point value at the specified non-negative offset.
 
 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:
 
 BufferOverflowException - If the specified offset exceeds the available capacity.
 - writeVolatileByte
```
@NotNull
public @NotNull HeapBytesStore writeVolatileByte(long offset,
 byte i8)
 throws BufferOverflowException
```
 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.
 
 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:
 
 BufferOverflowException - If the specified offset exceeds the available capacity.
 - writeVolatileShort
```
@NotNull
public @NotNull HeapBytesStore writeVolatileShort(long offset,
 short i16)
 throws BufferOverflowException
```
 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.
 
 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:
 
 BufferOverflowException - If the specified offset exceeds the available capacity.
 - writeVolatileInt
```
@NotNull
public @NotNull HeapBytesStore writeVolatileInt(long offset,
 int i32)
 throws BufferOverflowException
```
 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.
 
 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:
 
 BufferOverflowException - If the specified offset exceeds the available capacity.
 - writeVolatileLong
```
@NotNull
public @NotNull HeapBytesStore writeVolatileLong(long offset,
 long i64)
 throws BufferOverflowException
```
 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.
 
 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:
 
 BufferOverflowException - If the specified offset exceeds the available capacity.
 - write
```
@NotNull
public @NotNull HeapBytesStore write(long offsetInRDO,
 byte[] byteArray,
 int offset,
 int length)
 throws BufferOverflowException
```
 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()
 
 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:
 
 BufferOverflowException - if the capacity of this data output was exceeded.
 - write
```
public void write(long offsetInRDO,
 @NotNull
 @NotNull ByteBuffer bytes,
 int offset,
 int length)
 throws BufferOverflowException
```
 Description copied from interface: RandomDataOutput
 
 Copies a segment from the provided ByteBuffer into this data output.
 Does not update cursors e.g. writePosition()
 
 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:
 
 BufferOverflowException - if the capacity of this data output was exceeded.
 - write
```
@NotNull
public @NotNull HeapBytesStore write(long writeOffset,
 @NotNull
 @NotNull RandomDataInput bytes,
 long readOffset,
 long length)
 throws IllegalStateException,
 BufferUnderflowException,
 BufferOverflowException
```
 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.
 
 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:
 
 IllegalStateException - if this data output has been previously released.
 
 BufferUnderflowException - if the source does not have enough data to fill the length.
 
 BufferOverflowException - if the capacity of this data output was exceeded.
 - addressForRead
```
public long addressForRead(long offset)
 throws UnsupportedOperationException
```
 Retrieves the underlying memory address for reading. 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
 - addressForWrite
```
public long addressForWrite(long offset)
 throws UnsupportedOperationException
```
 Retrieves the underlying memory address for writing. 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
 - addressForWritePosition
```
public long addressForWritePosition()
 throws UnsupportedOperationException,
 BufferOverflowException
```
 Retrieves the underlying memory address for writing at the current write position. This is for expert users only.
 
 Returns:
 
 The underlying memory address for writing at the current write position.
 
 Throws:
 
 UnsupportedOperationException - if the underlying buffer is on the heap.
 
 BufferOverflowException - if the current write position is before the start or after the capacity.
 - nativeRead
```
public void nativeRead(long position,
 long address,
 long size)
```
 Description copied from interface: RandomDataInput
 
 Expert-level method for transferring data from this byte source to native memory.
 
 Parameters:
 
 position - the starting point within the byte source from which data is copied.
 
 address - the destination address in native memory.
 
 size - the number of bytes to transfer.
 - nativeWrite
```
public void nativeWrite(long address,
 long position,
 long size)
```
 Description copied from interface: RandomDataOutput
 
 Expert-level method that copies data directly from native memory into this BytesStore.
 
 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.
 - sharedMemory
```
public boolean sharedMemory()
```
 Checks if the Bytes use shared memory.
 
 Returns:
 
 True if the Bytes use shared memory, false otherwise.
 - hashCode
```
public int hashCode()
```
 Overrides:
 
 hashCode in class AbstractBytesStore<HeapBytesStore,U>
 - equals
```
public boolean equals(Object obj)
```
 Overrides:
 
 equals in class AbstractBytesStore<HeapBytesStore,U>
 - appendAndReturnLength
```
public long appendAndReturnLength(long writePosition,
 boolean negative,
 long mantissa,
 int exponent,
 boolean append0)
```
 - reverseBytesFrom
```
protected void reverseBytesFrom(long start,
 long end)
```
 - 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 HeapBytesStore<U>

Field Summary

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

Method Summary

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

Method Detail

forFields

wrap

wrap

isDirectMemory

move

toString

copy

performRelease

capacity

underlyingObject

compareAndSwapInt

testAndSetInt

compareAndSwapLong

read

readByte

readShort

readInt

readLong

readFloat

readDouble

readVolatileByte

readVolatileShort

readVolatileInt

readVolatileLong

write8bit

write8bit

writeByte

writeShort

writeInt

writeOrderedInt

writeLong

writeOrderedLong

writeFloat

writeDouble

writeVolatileByte

writeVolatileShort

writeVolatileInt

writeVolatileLong

write

write

write

addressForRead

addressForWrite

addressForWritePosition

nativeRead

nativeWrite

sharedMemory

hashCode

equals

appendAndReturnLength

reverseBytesFrom

writePosition

lengthWritten

realReadRemaining

realWriteRemaining

readLimit

writeLimit

addressForRead

byteOrder