NativeBytesStore (OpenHFT/Chronicle Bytes 2.24ea19 API)

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

All Implemented Interfaces:

CharSequence, BytesStore<NativeBytesStore,U>, RandomDataInput, RandomDataOutput<NativeBytesStore>, net.openhft.chronicle.core.io.ReferenceCounted, net.openhft.chronicle.core.io.ReferenceCountedTracer, net.openhft.chronicle.core.io.ReferenceOwner, net.openhft.chronicle.core.io.SingleThreadedChecked

Direct Known Subclasses:

MappedBytesStore, PointerBytesStore
```
public class NativeBytesStore
extends AbstractBytesStore<NativeBytesStore,U>
```

Field Summary

Fields
Modifier and Type Field and Description

long address

protected long limit

long maximumLimit

net.openhft.chronicle.core.Memory 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
`long`	`address`
`protected long`	`limit`
`long`	`maximumLimit`
`net.openhft.chronicle.core.Memory`	`memory`

Constructor Summary

Constructors
Modifier	Constructor and Description
	`NativeBytesStore(@NotNull ByteBuffer bb, boolean elastic, int maximumLimit)`
	`NativeBytesStore(long address, long limit)`
	`NativeBytesStore(long address, long limit, @Nullable Runnable deallocator, boolean elastic)`
`protected`	`NativeBytesStore(long address, long limit, @Nullable Runnable deallocator, boolean elastic, boolean monitored)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`int`	`addAndGetInt(long offset, int adding)` Adds an integer to the current integer value at the specified offset and returns the result.
`long`	`addAndGetLong(long offset, long adding)` Similar to `BytesStore.addAndGetInt(long, int)` but operates on a long value.
`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)`
`long`	`appendUtf8(long pos, char[] chars, int offset, int length)`
`protected void`	`backgroundPerformRelease()`
`int`	`byteCheckSum()` Returns the bytes sum of the readable bytes in this BytesStore.
`int`	`byteCheckSum(long position, long limit)` Returns the bytes sum between the specified indexes; start (inclusive) and end (exclusive).
`default ByteOrder`	`byteOrder()` Retrieves the byte order used by the buffer.
`@NotNull VanillaBytes<U>`	`bytesForWrite()` Returns a Bytes that wraps this ByteStore from the `start` to the `realCapacity`.
`boolean`	`canReadDirect(long length)` Checks if the specified length of bytes can be read directly from native memory.
`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<NativeBytesStore<U>,U>`	`copy()` Creates and returns a copy of this BytesStore.
`long`	`copyTo(@NotNull BytesStore store)` Returns the number of bytes that were copied from this BytesStore to a destination BytesStore.
`long`	`copyToDirect(@NotNull BytesStore store)`
`static @NotNull NativeBytesStore<ByteBuffer>`	`elasticByteBuffer()`
`static @NotNull NativeBytesStore<ByteBuffer>`	`elasticByteBuffer(int size, long maxSize)` Creates a flexible ByteBuffer instance that resides in native memory.
`boolean`	`equals(Object obj)`
`int`	`fastHash(long offset, int length)` Computes a hash code for a sequence of bytes.
`static @NotNull NativeBytesStore<ByteBuffer>`	`follow(@NotNull ByteBuffer bb)` Wraps a ByteBuffer which can be either on heap or off heap without taking ownership of that buffer.
`static @NotNull NativeBytesStore`	`from(byte[] bytes)`
`static @NotNull NativeBytesStore`	`from(@NotNull String text)` Converts a String into a BytesStore.
`int`	`hashCode()`
`void`	`init(@NotNull ByteBuffer bb, boolean elastic)` Deprecated. use `follow(ByteBuffer)` instead.
`boolean`	`isDirectMemory()` Checks if this BytesStore uses direct memory.
`boolean`	`isEqual(long start, long length, String s)` Returns if a specified portion of this BytesStore is equal to a specified String.
`static @NotNull NativeBytesStore<Void>`	`lazyNativeBytesStoreWithFixedCapacity(long capacity)` Creates a lazily initialized BytesStore instance with a fixed capacity that resides in native 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.
`static @NotNull NativeBytesStore<Void>`	`nativeStore(long capacity)` this is an elastic native store
`static @NotNull NativeBytesStore<Void>`	`nativeStoreWithFixedCapacity(long capacity)` Creates a BytesStore instance with a fixed capacity that resides in native memory.
`void`	`nativeWrite(long address, long position, long size)` Expert-level method that copies data directly from native memory into this BytesStore.
`int`	`peekUnsignedByte(long offset)` Reads an unsigned byte value from a specific offset.
`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.
`void`	`read8bit(long position, char[] chars, int length)`
`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.
`long`	`readIncompleteLong(long offset)` Reads a long value from the 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.
`int`	`readUnsignedByte(long offset)` Reads an unsigned byte 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.
`long`	`realCapacity()` Returns the actual capacity of the ByteStore before any resizing occurs.
`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)`
`long`	`safeLimit()`
`void`	`setAddress(long address)`
`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()`
`@NotNull ByteBuffer`	`toTemporaryDirectByteBuffer()` Converts the byte sequence into a direct byte buffer.
`long`	`translate(long offset)`
`U`	`underlyingObject()`
`void`	`uninit()` Deprecated. use `follow(ByteBuffer)` instead.
`static <T> @NotNull NativeBytesStore<T>`	`uninitialized()`
`static @NotNull NativeBytesStore<ByteBuffer>`	`wrap(@NotNull ByteBuffer bb)` Wraps a ByteBuffer into a BytesStore.
`@NotNull NativeBytesStore<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 NativeBytesStore<U>`	`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)`
`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 NativeBytesStore<U>`	`writeByte(long offset, byte i8)` Writes a byte at the specified non-negative offset.
`@NotNull NativeBytesStore<U>`	`writeDouble(long offset, double d)` Writes a double-precision floating-point value at the specified non-negative offset.
`@NotNull NativeBytesStore<U>`	`writeFloat(long offset, float f)` Writes a single-precision floating-point value at the specified non-negative offset.
`@NotNull NativeBytesStore<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 NativeBytesStore<U>`	`writeLong(long offset, long i64)` Writes a long integer value at the specified non-negative offset.
`@NotNull NativeBytesStore<U>`	`writeOrderedInt(long offset, int i)` Performs a non-blocking write operation with a memory barrier to ensure order of stores.
`@NotNull NativeBytesStore<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 NativeBytesStore<U>`	`writeShort(long offset, short i16)` Writes a short integer at the specified non-negative offset.
`@NotNull NativeBytesStore<U>`	`writeVolatileByte(long offset, byte i8)` Writes a volatile byte at the specified non-negative offset.
`@NotNull NativeBytesStore<U>`	`writeVolatileInt(long offset, int i32)` Writes a volatile integer at the specified non-negative offset.
`@NotNull NativeBytesStore<U>`	`writeVolatileLong(long offset, long i64)` Writes a volatile long integer at the specified non-negative offset.
`@NotNull NativeBytesStore<U>`	`writeVolatileShort(long offset, short i16)` Writes a volatile short at the specified non-negative offset.
`@NotNull NativeBytesStore<U>`	`zeroOut(long start, long end)` Fills the BytesStore with zeros.

Methods inherited from class net.openhft.chronicle.bytes.internal.AbstractBytesStore
canReleaseInBackground, internalNumberBuffer, readPosition, readRemaining, start, 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, bytesForRead, bytesStore, charAt, cipher, cipher, compareAndSwapDouble, compareAndSwapFloat, contentEquals, copyTo, empty, endsWith, equalBytes, forFields, from, from, hash, inside, inside, 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
 - address
```
public long address
```
 - memory
```
public net.openhft.chronicle.core.Memory memory
```
 - maximumLimit
```
public long maximumLimit
```
 - limit
```
protected long limit
```
- Constructor Detail
 - NativeBytesStore
```
public NativeBytesStore(@NotNull
 @NotNull ByteBuffer bb,
 boolean elastic,
 int maximumLimit)
```
 - NativeBytesStore
```
public NativeBytesStore(long address,
 long limit)
```
 - NativeBytesStore
```
public NativeBytesStore(long address,
 long limit,
 @Nullable
 @Nullable Runnable deallocator,
 boolean elastic)
```
 - NativeBytesStore
```
protected NativeBytesStore(long address,
 long limit,
 @Nullable
 @Nullable Runnable deallocator,
 boolean elastic,
 boolean monitored)
```
- Method Detail
 - wrap
```
@NotNull
public static @NotNull NativeBytesStore<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 - ByteBuffer
 
 Returns:
 
 BytesStore
 
 See Also:
 
 BytesStore.wrap(ByteBuffer)
 - follow
```
@NotNull
public static @NotNull NativeBytesStore<ByteBuffer> follow(@NotNull
 @NotNull ByteBuffer bb)
```
 Description copied from interface: BytesStore
 
 Wraps a ByteBuffer which can be either on heap or off heap without taking ownership of that buffer.
 When resulting BytesStore instance is closed, direct byteBuffer will not be deallocated so its life cycle should be tracked elsewhere.
 
 Parameters:
 
 bb - ByteBuffer
 
 Returns:
 
 BytesStore
 
 See Also:
 
 BytesStore.follow(ByteBuffer)
 - uninitialized
```
@NotNull
public static <T> @NotNull NativeBytesStore<T> uninitialized()
```
 - nativeStore
```
@NotNull
public static @NotNull NativeBytesStore<Void> nativeStore(long capacity)
 throws IllegalArgumentException
```
 this is an elastic native store
 
 Parameters:
 
 capacity - of the buffer.
 
 Returns:
 
 a BytesStore with the provided capacity in native memory
 
 Throws:
 
 IllegalArgumentException
 - nativeStoreWithFixedCapacity
```
@NotNull
public static @NotNull NativeBytesStore<Void> nativeStoreWithFixedCapacity(long capacity)
 throws IllegalArgumentException
```
 Description copied from interface: BytesStore
 
 Creates a BytesStore instance with a fixed capacity that resides in native memory.
 
 Parameters:
 
 capacity - the fixed capacity of the buffer
 
 Returns:
 
 a BytesStore with the provided fixed capacity in native memory
 
 Throws:
 
 IllegalArgumentException
 - lazyNativeBytesStoreWithFixedCapacity
```
@NotNull
public static @NotNull NativeBytesStore<Void> lazyNativeBytesStoreWithFixedCapacity(long capacity)
 throws IllegalArgumentException
```
 Description copied from interface: BytesStore
 
 Creates a lazily initialized BytesStore instance with a fixed capacity that resides in native memory.
 
 Parameters:
 
 capacity - the fixed capacity of the buffer
 
 Returns:
 
 a BytesStore with the provided fixed capacity in native memory, initialized on demand
 
 Throws:
 
 IllegalArgumentException
 - elasticByteBuffer
```
@NotNull
public static @NotNull NativeBytesStore<ByteBuffer> elasticByteBuffer()
```
 - elasticByteBuffer
```
@NotNull
public static @NotNull NativeBytesStore<ByteBuffer> elasticByteBuffer(int size,
 long maxSize)
```
 Description copied from interface: BytesStore
 
 Creates a flexible ByteBuffer instance that resides in native memory.
 
 Parameters:
 
 size - the initial size of the ByteBuffer
 
 maxSize - the maximum allowable size of the ByteBuffer
 
 Returns:
 
 a ByteBuffer with the provided initial size and maximum size in native memory
 - from
```
@NotNull
public static @NotNull NativeBytesStore from(@NotNull
 @NotNull String text)
```
 Description copied from interface: BytesStore
 
 Converts a String into a BytesStore. The characters in the String are encoded using ISO_8859_1.
 
 Parameters:
 
 text - the String to be converted
 
 Returns:
 
 a BytesStore which contains the bytes from the String
 - from
```
@NotNull
public static @NotNull NativeBytesStore from(byte[] bytes)
```
 - 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
 - canReadDirect
```
public boolean canReadDirect(long length)
```
 Description copied from interface: RandomDataInput
 
 Checks if the specified length of bytes can be read directly from native memory.
 
 Parameters:
 
 length - the number of bytes to check.
 
 Returns:
 
 true if the byte sequence is backed by direct memory and the remaining bytes are more than or equal to the specified length, false otherwise.
 - init
```
@Deprecated
public void init(@NotNull
 @NotNull ByteBuffer bb,
 boolean elastic)
```
 Deprecated. use follow(ByteBuffer) instead.
 - uninit
```
@Deprecated
public void uninit()
```
 Deprecated. use follow(ByteBuffer) instead.
 - move
```
public void move(long from,
 long to,
 long length)
 throws BufferUnderflowException,
 net.openhft.chronicle.core.io.ClosedIllegalStateException
```
 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
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
 - copy
```
@NotNull
public @NotNull BytesStore<NativeBytesStore,U> copy()
 throws net.openhft.chronicle.core.io.ClosedIllegalStateException
```
 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
 
 Throws:
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
 - bytesForWrite
```
@NotNull
public @NotNull VanillaBytes bytesForWrite()
 throws net.openhft.chronicle.core.io.ClosedIllegalStateException,
 net.openhft.chronicle.core.io.ThreadingIllegalStateException
```
 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 BytesStore
 
 Throws:
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
 
 net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way.
 - realCapacity
```
public long realCapacity()
```
 Description copied from interface: BytesStore
 
 Returns the actual capacity of the ByteStore before any resizing occurs.
 
 Returns:
 
 the current capacity of the ByteStore
 - 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
```
@Nullable
public U underlyingObject()
```
 Returns:
 
 the underlying object being wrapped, if there is one, or null if not.
 - zeroOut
```
@NotNull
public @NotNull NativeBytesStore zeroOut(long start,
 long end)
```
 Description copied from interface: BytesStore
 
 Fills the BytesStore with zeros.
 
 Parameters:
 
 start - first byte inclusive
 
 end - last byte exclusive
 
 Returns:
 
 this
 - compareAndSwapInt
```
public boolean compareAndSwapInt(long offset,
 int expected,
 int value)
 throws net.openhft.chronicle.core.io.ClosedIllegalStateException,
 net.openhft.chronicle.core.io.ThreadingIllegalStateException
```
 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.
 
 Throws:
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
 
 net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
 - testAndSetInt
```
public void testAndSetInt(long offset,
 int expected,
 int value)
 throws net.openhft.chronicle.core.io.ClosedIllegalStateException
```
 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:
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
 - compareAndSwapLong
```
public boolean compareAndSwapLong(long offset,
 long expected,
 long value)
 throws net.openhft.chronicle.core.io.ClosedIllegalStateException,
 net.openhft.chronicle.core.io.ThreadingIllegalStateException
```
 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.
 
 Throws:
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
 
 net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
 - addAndGetLong
```
public long addAndGetLong(long offset,
 long adding)
 throws BufferUnderflowException
```
 Description copied from interface: BytesStore
 
 Similar to BytesStore.addAndGetInt(long, int) but operates on a long value.
 
 Parameters:
 
 offset - to add and get
 
 adding - value to add, can be 1
 
 Returns:
 
 the sum
 
 Throws:
 
 BufferUnderflowException - If the offset is outside the limits of the Bytes
 - addAndGetInt
```
public int addAndGetInt(long offset,
 int adding)
 throws BufferUnderflowException
```
 Description copied from interface: BytesStore
 
 Adds an integer to the current integer value at the specified offset and returns the result.
 
 Parameters:
 
 offset - the position where the integer is stored
 
 adding - the integer to add
 
 Returns:
 
 the result of the addition
 
 Throws:
 
 BufferUnderflowException - If the offset is out of bounds
 - translate
```
public long translate(long offset)
```
 - readByte
```
public byte readByte(long offset)
```
 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.
 - readUnsignedByte
```
public int readUnsignedByte(long offset)
 throws BufferUnderflowException
```
 Description copied from interface: RandomDataInput
 
 Reads an unsigned byte value from a specific offset. The value is returned as an int in order to represent the unsigned byte as a positive value.
 
 Parameters:
 
 offset - the location from where the unsigned byte value is read.
 
 Returns:
 
 the unsigned byte value interpreted as a positive int.
 
 Throws:
 
 BufferUnderflowException - If the offset is outside the bounds of the byte source.
 - readShort
```
public short readShort(long offset)
```
 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.
 - readInt
```
public int readInt(long offset)
```
 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.
 - readLong
```
public long readLong(long offset)
```
 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.
 - readFloat
```
public float readFloat(long offset)
```
 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.
 - readDouble
```
public double readDouble(long offset)
```
 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.
 - readVolatileByte
```
public byte readVolatileByte(long offset)
```
 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.
 - readVolatileShort
```
public short readVolatileShort(long offset)
```
 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.
 - readVolatileInt
```
public int readVolatileInt(long offset)
```
 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.
 - readVolatileLong
```
public long readVolatileLong(long offset)
```
 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.
 - writeByte
```
@NotNull
public @NotNull NativeBytesStore writeByte(long offset,
 byte i8)
 throws net.openhft.chronicle.core.io.ClosedIllegalStateException,
 net.openhft.chronicle.core.io.ThreadingIllegalStateException
```
 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.
 
 i8 - The byte value to write.
 
 Returns:
 
 Reference to the current instance, allowing for method chaining.
 
 Throws:
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
 
 net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
 - writeShort
```
@NotNull
public @NotNull NativeBytesStore writeShort(long offset,
 short i16)
 throws net.openhft.chronicle.core.io.ClosedIllegalStateException,
 net.openhft.chronicle.core.io.ThreadingIllegalStateException
```
 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:
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
 
 net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
 - writeInt
```
@NotNull
public @NotNull NativeBytesStore writeInt(long offset,
 int i32)
 throws net.openhft.chronicle.core.io.ClosedIllegalStateException,
 net.openhft.chronicle.core.io.ThreadingIllegalStateException
```
 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:
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
 
 net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
 - writeOrderedInt
```
@NotNull
public @NotNull NativeBytesStore writeOrderedInt(long offset,
 int i)
```
 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.
 
 i - The integer value to write.
 
 Returns:
 
 Reference to the current instance, allowing for method chaining.
 - writeLong
```
@NotNull
public @NotNull NativeBytesStore writeLong(long offset,
 long i64)
 throws net.openhft.chronicle.core.io.ClosedIllegalStateException,
 net.openhft.chronicle.core.io.ThreadingIllegalStateException
```
 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:
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
 
 net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
 - writeOrderedLong
```
@NotNull
public @NotNull NativeBytesStore writeOrderedLong(long offset,
 long i)
 throws net.openhft.chronicle.core.io.ClosedIllegalStateException,
 net.openhft.chronicle.core.io.ThreadingIllegalStateException
```
 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:
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
 
 net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
 - writeFloat
```
@NotNull
public @NotNull NativeBytesStore writeFloat(long offset,
 float f)
 throws net.openhft.chronicle.core.io.ClosedIllegalStateException,
 net.openhft.chronicle.core.io.ThreadingIllegalStateException
```
 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:
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
 
 net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
 - writeDouble
```
@NotNull
public @NotNull NativeBytesStore writeDouble(long offset,
 double d)
 throws net.openhft.chronicle.core.io.ClosedIllegalStateException,
 net.openhft.chronicle.core.io.ThreadingIllegalStateException
```
 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:
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
 
 net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
 - writeVolatileByte
```
@NotNull
public @NotNull NativeBytesStore writeVolatileByte(long offset,
 byte i8)
 throws net.openhft.chronicle.core.io.ClosedIllegalStateException,
 net.openhft.chronicle.core.io.ThreadingIllegalStateException
```
 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:
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
 
 net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
 - writeVolatileShort
```
@NotNull
public @NotNull NativeBytesStore writeVolatileShort(long offset,
 short i16)
 throws net.openhft.chronicle.core.io.ClosedIllegalStateException,
 net.openhft.chronicle.core.io.ThreadingIllegalStateException
```
 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:
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
 
 net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
 - writeVolatileInt
```
@NotNull
public @NotNull NativeBytesStore writeVolatileInt(long offset,
 int i32)
 throws net.openhft.chronicle.core.io.ClosedIllegalStateException,
 net.openhft.chronicle.core.io.ThreadingIllegalStateException
```
 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:
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
 
 net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
 - writeVolatileLong
```
@NotNull
public @NotNull NativeBytesStore writeVolatileLong(long offset,
 long i64)
 throws net.openhft.chronicle.core.io.ClosedIllegalStateException,
 net.openhft.chronicle.core.io.ThreadingIllegalStateException
```
 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:
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
 
 net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
 - write
```
@NotNull
public @NotNull NativeBytesStore write(long offsetInRDO,
 byte[] byteArray,
 int offset,
 int length)
 throws net.openhft.chronicle.core.io.ClosedIllegalStateException,
 net.openhft.chronicle.core.io.ThreadingIllegalStateException
```
 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:
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
 
 net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
 - write
```
public void write(long offsetInRDO,
 @NotNull
 @NotNull ByteBuffer bytes,
 int offset,
 int length)
 throws net.openhft.chronicle.core.io.ClosedIllegalStateException,
 net.openhft.chronicle.core.io.ThreadingIllegalStateException
```
 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:
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
 
 net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
 - write
```
@NotNull
public @NotNull NativeBytesStore write(long writeOffset,
 @NotNull
 @NotNull RandomDataInput bytes,
 long readOffset,
 long length)
 throws BufferOverflowException,
 BufferUnderflowException,
 net.openhft.chronicle.core.io.ClosedIllegalStateException,
 net.openhft.chronicle.core.io.ThreadingIllegalStateException
```
 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:
 
 BufferOverflowException - If the capacity of this data output was exceeded.
 
 BufferUnderflowException - If the source does not have enough data to fill the length.
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
 
 net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
 - write0
```
public void write0(long offsetInRDO,
 @NotNull
 @NotNull RandomDataInput bytes,
 long offset,
 long length)
 throws BufferUnderflowException,
 net.openhft.chronicle.core.io.ClosedIllegalStateException
```
 Throws:
 
 BufferUnderflowException
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException
 - addressForRead
```
public long addressForRead(long offset)
 throws BufferUnderflowException
```
 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:
 
 BufferUnderflowException - If the offset is before the start() or the after the capacity()
 - addressForWrite
```
public long addressForWrite(long offset)
 throws BufferOverflowException
```
 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:
 
 BufferOverflowException - If the offset is before the start() or the after the capacity()
 - 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.
 - backgroundPerformRelease
```
protected void backgroundPerformRelease()
```
 Overrides:
 
 backgroundPerformRelease in class net.openhft.chronicle.core.io.AbstractReferenceCounted
 - performRelease
```
protected void performRelease()
```
 Specified by:
 
 performRelease in class net.openhft.chronicle.core.io.AbstractReferenceCounted
 - toString
```
@NotNull
public @NotNull String toString()
```
 Specified by:
 
 toString in interface CharSequence
 
 Overrides:
 
 toString in class net.openhft.chronicle.core.io.AbstractReferenceCounted
 - nativeRead
```
public void nativeRead(long position,
 long address,
 long size)
 throws BufferUnderflowException,
 net.openhft.chronicle.core.io.ClosedIllegalStateException
```
 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.
 
 Throws:
 
 BufferUnderflowException - If the specified position or size exceeds the byte source limits.
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
 - nativeWrite
```
public void nativeWrite(long address,
 long position,
 long size)
 throws BufferOverflowException,
 net.openhft.chronicle.core.io.ClosedIllegalStateException,
 net.openhft.chronicle.core.io.ThreadingIllegalStateException
```
 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.
 
 Throws:
 
 BufferOverflowException - If the capacity of this BytesStore was exceeded.
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
 
 net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
 - 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)
 throws net.openhft.chronicle.core.io.ClosedIllegalStateException
```
 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.
 
 Throws:
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
 - read8bit
```
public void read8bit(long position,
 char[] chars,
 int length)
```
 - readIncompleteLong
```
public long readIncompleteLong(long offset)
```
 Description copied from interface: RandomDataInput
 
 Reads a long value from the specified offset. If less than 8 bytes are available to read, this method pads the high bytes with zeros. If the offset is at or beyond the read limit, this method returns 0L.
 
 Parameters:
 
 offset - the location from where the long value is read.
 
 Returns:
 
 the long value, potentially zero-padded.
 - setAddress
```
public void setAddress(long address)
```
 - appendUtf8
```
public long appendUtf8(long pos,
 char[] chars,
 int offset,
 int length)
 throws BufferOverflowException,
 net.openhft.chronicle.core.io.ClosedIllegalStateException,
 net.openhft.chronicle.core.io.ThreadingIllegalStateException
```
 Throws:
 
 BufferOverflowException
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException
 
 net.openhft.chronicle.core.io.ThreadingIllegalStateException
 - copyTo
```
public long copyTo(@NotNull
 @NotNull BytesStore store)
 throws net.openhft.chronicle.core.io.ClosedIllegalStateException
```
 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.
 
 Parameters:
 
 store - the BytesStore to copy to
 
 Returns:
 
 how many bytes were copied
 
 Throws:
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
 - copyToDirect
```
public long copyToDirect(@NotNull
 @NotNull BytesStore store)
 throws net.openhft.chronicle.core.io.ClosedIllegalStateException
```
 Throws:
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException
 - toTemporaryDirectByteBuffer
```
@NotNull
public @NotNull ByteBuffer toTemporaryDirectByteBuffer()
```
 Description copied from interface: RandomDataInput
 
 Converts the byte sequence into a direct byte buffer.
 
 Returns:
 
 a direct ByteBuffer containing the data of this byte sequence.
 - byteCheckSum
```
public int byteCheckSum()
 throws net.openhft.chronicle.core.io.IORuntimeException
```
 Description copied from interface: BytesStore
 
 Returns the bytes sum of the readable bytes in this BytesStore.
 
 Returns:
 
 unsigned bytes sum
 
 Throws:
 
 net.openhft.chronicle.core.io.IORuntimeException
 - byteCheckSum
```
public int byteCheckSum(long position,
 long limit)
```
 Description copied from interface: BytesStore
 
 Returns the bytes sum between the specified indexes; start (inclusive) and end (exclusive).
 
 Parameters:
 
 position - the index of the first byte to sum
 
 limit - the index of the last byte to sum
 
 Returns:
 
 unsigned bytes sum
 - sharedMemory
```
public boolean sharedMemory()
```
 Checks if the Bytes use shared memory.
 
 Returns:
 
 True if the Bytes use shared memory, false otherwise.
 - 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.
 - peekUnsignedByte
```
public int peekUnsignedByte(long offset)
```
 Description copied from interface: RandomDataInput
 
 Reads an unsigned byte value from a specific offset. Returns -1 if the byte read is at the end of the byte source. The value is returned as an int in order to represent the unsigned byte as a positive value.
 
 Specified by:
 
 peekUnsignedByte in interface RandomDataInput
 
 Overrides:
 
 peekUnsignedByte in class AbstractBytesStore<NativeBytesStore,U>
 
 Parameters:
 
 offset - the location from where the unsigned byte value is read.
 
 Returns:
 
 the unsigned byte value interpreted as a positive int or -1.
 - fastHash
```
public int fastHash(long offset,
 int length)
 throws BufferUnderflowException,
 net.openhft.chronicle.core.io.ClosedIllegalStateException
```
 Description copied from interface: RandomDataInput
 
 Computes a hash code for a sequence of bytes.
 
 Parameters:
 
 offset - the start offset of the sequence of bytes.
 
 length - the length of the sequence of bytes.
 
 Returns:
 
 a hash code value for the specified sequence of bytes.
 
 Throws:
 
 BufferUnderflowException - If the specified sequence of bytes extends beyond the limits of this byte sequence.
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
 - safeLimit
```
public long safeLimit()
```
 Returns:
 
 how many bytes can be safely read, i.e. what is the real capacity of the underlying data.
 - isEqual
```
public boolean isEqual(long start,
 long length,
 String s)
```
 Description copied from interface: BytesStore
 
 Returns if a specified portion of this BytesStore is equal to a specified String. The portion is specified with its offset and length.
 
 Parameters:
 
 start - the portion offset
 
 length - the number of bytes from this BytesStore that should be compared to s
 
 s - the String to compare to
 
 Returns:
 
 true if the specified portion of this BytesStore is equal to s
 - hashCode
```
public int hashCode()
```
 Overrides:
 
 hashCode in class AbstractBytesStore<NativeBytesStore,U>
 - equals
```
public boolean equals(Object obj)
```
 Overrides:
 
 equals in class AbstractBytesStore<NativeBytesStore,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,
 net.openhft.chronicle.core.io.ClosedIllegalStateException,
 net.openhft.chronicle.core.io.ThreadingIllegalStateException
```
 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.
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
 
 net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
 - byteOrder
```
public ByteOrder byteOrder()
```
 Retrieves the byte order used by the buffer.
 
 Returns:
 
 The byte order used by the buffer.

Class NativeBytesStore<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

Constructor Summary

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

Field Detail

address

memory

maximumLimit

limit

Constructor Detail

NativeBytesStore

NativeBytesStore

NativeBytesStore

NativeBytesStore

Method Detail

wrap

follow

uninitialized

nativeStore

nativeStoreWithFixedCapacity

lazyNativeBytesStoreWithFixedCapacity

elasticByteBuffer

elasticByteBuffer

from

from

isDirectMemory

canReadDirect

init

uninit

move

copy

bytesForWrite

realCapacity

capacity

underlyingObject

zeroOut

compareAndSwapInt

testAndSetInt

compareAndSwapLong

addAndGetLong

addAndGetInt

translate

readByte

readUnsignedByte

readShort

readInt

readLong

readFloat

readDouble

readVolatileByte

readVolatileShort

readVolatileInt

readVolatileLong

writeByte

writeShort

writeInt

writeOrderedInt

writeLong

writeOrderedLong

writeFloat

writeDouble

writeVolatileByte

writeVolatileShort

writeVolatileInt

writeVolatileLong

write