RandomDataOutput (OpenHFT/Chronicle-Bytes 2.24ea8 API)

All Known Subinterfaces:

Bytes<U>, BytesStore<B,U>

All Known Implementing Classes:

AbstractBytes, AbstractBytesStore, ChunkedMappedBytes, CommonMappedBytes, EmbeddedBytes, GuardedNativeBytes, HeapBytesStore, HexDumpBytes, MappedBytes, MappedBytesStore, NativeBytes, NativeBytesStore, NoBytesStore, NoBytesStore, OnHeapBytes, PointerBytesStore, SingleMappedBytes, SubBytes, UncheckedBytes, UncheckedNativeBytes, VanillaBytes
```
public interface RandomDataOutput<R extends RandomDataOutput<R>>
```

Field Summary
- Fields inherited from interface net.openhft.chronicle.core.io.ReferenceOwner
  INIT, TMP

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`double`	`addAndGetDouble(long offset, double adding)` Perform an atomic add and get operation for a 64-bit double
`float`	`addAndGetFloat(long offset, float adding)` Perform an atomic add and get operation for a 32-bit float
`int`	`addAndGetInt(long offset, int adding)` Perform an atomic add and get operation for a 32-bit int
`long`	`addAndGetLong(long offset, long adding)` Perform an atomic add and get operation for a 64-bit long
`long`	`addressForRead(long offset)` Obtain the underlying addressForRead.
`default long`	`addressForRead(long offset, int buffer)`
`long`	`addressForWrite(long offset)` Obtain the underlying addressForRead.
`long`	`addressForWritePosition()`
`default R`	`append(long offset, double value, int decimalPlaces, int digits)`
`default R`	`append(long offset, long value, int digits)`
`default ByteOrder`	`byteOrder()`
`@NotNull Bytes<?>`	`bytesForRead()`
`@NotNull Bytes<?>`	`bytesForWrite()`
`default long`	`capacity()`
`boolean`	`compareAndSwapDouble(long offset, double expected, double value)` Perform a 64-bit double CAS at a given offset.
`boolean`	`compareAndSwapFloat(long offset, float expected, float value)` Perform a 32-bit float CAS at a given offset.
`boolean`	`compareAndSwapInt(long offset, int expected, int value)` Perform a 32-bit CAS at a given offset.
`boolean`	`compareAndSwapLong(long offset, long expected, long value)` Perform a 64-bit CAS at a given offset.
`byte[]`	`internalNumberBuffer()`
`boolean`	`isDirectMemory()`
`default long`	`lengthWritten(long startPosition)` Typically this calculates the difference however for HexDumpBytes it's not as simple.
`void`	`nativeWrite(long address, long position, long size)` expert level method to copy data from native memory into the BytesStore
`default long`	`readLimit()` If the resource is closed, the returned value is unspecified.
`default long`	`readPosition()` Returns the read position.
`default long`	`readRemaining()` Returns the remaining bytes that can be read.
`default long`	`realCapacity()`
`default long`	`realReadRemaining()` If the resource is closed, the returned value is unspecified.
`default long`	`realWriteRemaining()` If the resource is closed, the returned value is unspecified.
`boolean`	`sharedMemory()`
`default long`	`start()`
`void`	`testAndSetInt(long offset, int expected, int value)`
`default R`	`write(long offsetInRDO, byte[] bytes)` Copies whole byte[] into this.
`R`	`write(long writeOffset, byte[] byteArray, int readOffset, 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 writeOffset, @NotNull ByteBuffer bytes, int readOffset, int length)` Copy from ByteBuffer into this.
`default R`	`write(long offsetInRDO, @NotNull BytesStore bytes)` Copies whole BytesStore into this - see `write(long, RandomDataInput, long, long)`
`R`	`write(long writeOffset, @NotNull RandomDataInput bytes, long readOffset, long length)` Copy from RandomDataInput into this.
`long`	`write8bit(long position, @NotNull BytesStore bs)` Write the stop bit length and copy the BytesStore
`long`	`write8bit(long position, @NotNull String s, int start, int length)`
`default R`	`writeBoolean(long offset, boolean flag)` Write a boolean at an offset.
`R`	`writeByte(long offset, byte i8)` Write an unsigned byte at an offset.
`default R`	`writeByte(long offset, int i)` Write a byte at an offset.
`R`	`writeDouble(long offset, double d)` Write a double at an offset.
`R`	`writeFloat(long offset, float d)` Write a float at an offset.
`R`	`writeInt(long offset, int i)` Write an int at an offset.
`default R`	`writeInt24(long offset, int i)`
`default long`	`writeLimit()` Returns the write limit.
`R`	`writeLong(long offset, long i)` Write a long at an offset.
`default R`	`writeOrderedDouble(long offset, double d)` Perform a non stalling write with a store barrier.
`default R`	`writeOrderedFloat(long offset, float f)` Perform a non stalling write with a store barrier.
`R`	`writeOrderedInt(long offset, int i)` Perform a non stalling write with a store barrier.
`R`	`writeOrderedLong(long offset, long i)` Perform a non stalling write with a store barrier.
`default long`	`writePosition()` Returns the write position.
`default long`	`writeRemaining()` If the resource is closed, the returned value is unspecified.
`R`	`writeShort(long offset, short i)` Write a short at an offset.
`default R`	`writeUnsignedByte(long offset, int i)` Write an unsigned byte at an offset.
`default R`	`writeUnsignedInt(long offset, long i)` Write an unsigned byte at an offset.
`default R`	`writeUnsignedShort(long offset, int i)` Write an unsigned byte at an offset.
`default long`	`writeUtf8(long writeOffset, @Nullable CharSequence text)` Writes the provided `text` into this `RandomDataOutput` writing at the given `writeOffset`, in Utf8 format.
`default long`	`writeUtf8Limited(long writeOffset, @Nullable CharSequence text, int maxUtf8Len)` Writes the given `text` to this `RandomDataOutput` writing at the provided `writeOffset`, in Utf8 format, checking that the utf8 encoding size of the given char sequence is less or equal to the provided `maxUtf8Len`, otherwise `IllegalArgumentException` is thrown, and no bytes of this `RandomDataOutput` are overwritten.
`R`	`writeVolatileByte(long offset, byte i8)`
`default R`	`writeVolatileDouble(long offset, double d)`
`default R`	`writeVolatileFloat(long offset, float f)`
`R`	`writeVolatileInt(long offset, int i32)`
`R`	`writeVolatileLong(long offset, long i64)`
`R`	`writeVolatileShort(long offset, short i16)`
`R`	`zeroOut(long start, long end)` Zero out the bytes between the start and the end.

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

- Method Detail
  - writeByte
```
@NotNull
default R writeByte(long offset,
                             int i)
                      throws BufferOverflowException,
                             IllegalArgumentException,
                             ArithmeticException,
                             IllegalStateException
```
    Write a byte at an offset.
    
    Parameters:
    
    offset - to write to
    
    i - the value
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
    
    IllegalArgumentException - if the value cannot be cast to the type without loss.
    
    ArithmeticException
    
    IllegalStateException
  - writeUnsignedByte
```
@NotNull
default R writeUnsignedByte(long offset,
                                     int i)
                              throws BufferOverflowException,
                                     IllegalArgumentException,
                                     ArithmeticException,
                                     IllegalStateException
```
    Write an unsigned byte at an offset.
    
    Parameters:
    
    offset - to write to
    
    i - the value
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
    
    IllegalArgumentException - if the value cannot be cast to the type without loss.
    
    ArithmeticException
    
    IllegalStateException
  - writeBoolean
```
@NotNull
default R writeBoolean(long offset,
                                boolean flag)
                         throws BufferOverflowException,
                                IllegalStateException
```
    Write a boolean at an offset.
    
    Parameters:
    
    offset - to write to
    
    flag - the value
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
    
    IllegalStateException
  - writeUnsignedShort
```
@NotNull
default R writeUnsignedShort(long offset,
                                      int i)
                               throws BufferOverflowException,
                                      ArithmeticException,
                                      IllegalStateException
```
    Write an unsigned byte at an offset.
    
    Parameters:
    
    offset - to write to
    
    i - the value
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
    
    ArithmeticException - if the value cannot be cast to the type without loss.
    
    IllegalStateException
  - writeUnsignedInt
```
@NotNull
default R writeUnsignedInt(long offset,
                                    long i)
                             throws BufferOverflowException,
                                    ArithmeticException,
                                    IllegalStateException
```
    Write an unsigned byte at an offset.
    
    Parameters:
    
    offset - to write to
    
    i - the value
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
    
    ArithmeticException - if the value cannot be cast to the type without loss.
    
    IllegalStateException
  - writeByte
```
@NotNull
R writeByte(long offset,
                     byte i8)
              throws BufferOverflowException,
                     IllegalStateException
```
    Write an unsigned byte at an offset.
    
    Parameters:
    
    offset - to write to
    
    i8 - the value
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
    
    IllegalStateException
  - writeShort
```
@NotNull
R writeShort(long offset,
                      short i)
               throws BufferOverflowException,
                      IllegalStateException
```
    Write a short at an offset.
    
    Parameters:
    
    offset - to write to
    
    i - the value
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
    
    IllegalStateException
  - writeInt24
```
@NotNull
default R writeInt24(long offset,
                              int i)
                       throws BufferOverflowException,
                              IllegalStateException
```
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
  - writeInt
```
@NotNull
R writeInt(long offset,
                    int i)
             throws BufferOverflowException,
                    IllegalStateException
```
    Write an int at an offset.
    
    Parameters:
    
    offset - to write to
    
    i - the value
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
    
    IllegalStateException
  - writeOrderedInt
```
@NotNull
R writeOrderedInt(long offset,
                           int i)
                    throws BufferOverflowException,
                           IllegalStateException
```
    Perform a non stalling write with a store barrier.
    
    Parameters:
    
    offset - to write to
    
    i - value to write
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
    
    IllegalStateException
  - writeOrderedFloat
```
@NotNull
default R writeOrderedFloat(long offset,
                                     float f)
                              throws BufferOverflowException,
                                     IllegalStateException
```
    Perform a non stalling write with a store barrier.
    
    Parameters:
    
    offset - to write to
    
    f - value to write
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
    
    IllegalStateException
  - writeLong
```
@NotNull
R writeLong(long offset,
                     long i)
              throws BufferOverflowException,
                     IllegalStateException
```
    Write a long at an offset.
    
    Parameters:
    
    offset - to write to
    
    i - the value
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
    
    IllegalStateException
  - writeOrderedLong
```
@NotNull
R writeOrderedLong(long offset,
                            long i)
                     throws BufferOverflowException,
                            IllegalStateException
```
    Perform a non stalling write with a store barrier.
    
    Parameters:
    
    offset - to write to
    
    i - value to write
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
  - writeOrderedDouble
```
@NotNull
default R writeOrderedDouble(long offset,
                                      double d)
                               throws BufferOverflowException,
                                      IllegalStateException
```
    Perform a non stalling write with a store barrier.
    
    Parameters:
    
    offset - to write to
    
    d - value to write
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
  - writeFloat
```
@NotNull
R writeFloat(long offset,
                      float d)
               throws BufferOverflowException,
                      IllegalStateException
```
    Write a float at an offset.
    
    Parameters:
    
    offset - to write to
    
    d - the value
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
    
    IllegalStateException
  - writeDouble
```
@NotNull
R writeDouble(long offset,
                       double d)
                throws BufferOverflowException,
                       IllegalStateException
```
    Write a double at an offset.
    
    Parameters:
    
    offset - to write to
    
    d - the value
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
    
    IllegalStateException
  - writeVolatileByte
```
@NotNull
R writeVolatileByte(long offset,
                             byte i8)
                      throws BufferOverflowException,
                             IllegalStateException
```
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
  - writeVolatileShort
```
@NotNull
R writeVolatileShort(long offset,
                              short i16)
                       throws BufferOverflowException,
                              IllegalStateException
```
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
  - writeVolatileInt
```
@NotNull
R writeVolatileInt(long offset,
                            int i32)
                     throws BufferOverflowException,
                            IllegalStateException
```
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
  - writeVolatileLong
```
@NotNull
R writeVolatileLong(long offset,
                             long i64)
                      throws BufferOverflowException,
                             IllegalStateException
```
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
  - writeVolatileFloat
```
@NotNull
default R writeVolatileFloat(long offset,
                                      float f)
                               throws BufferOverflowException,
                                      IllegalStateException
```
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
  - writeVolatileDouble
```
@NotNull
default R writeVolatileDouble(long offset,
                                       double d)
                                throws BufferOverflowException,
                                       IllegalStateException
```
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
  - write
```
@NotNull
default R write(long offsetInRDO,
                         byte[] bytes)
                  throws BufferOverflowException,
                         IllegalStateException
```
    Copies whole byte[] into this. See write(long, byte[], int, int)
    
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
  - write
```
@NotNull
R write(long writeOffset,
                 byte[] byteArray,
                 int readOffset,
                 int length)
          throws BufferOverflowException,
                 IllegalStateException
```
    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:
    
    writeOffset - non-negative offset to write to
    
    byteArray - non-null copy from byteArray
    
    readOffset - non-negative copy from offset
    
    length - non-negative length to copy
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if this Bytes object cannot accommodate all the bytes to copy.
    
    IllegalStateException - if this Bytes object has been previously released
    
    IllegalArgumentException - if the provided writeOffset, readOffset or length is negative
    
    NullPointerException - if the provided byteArray is null
  - write
```
void write(long writeOffset,
           @NotNull
           @NotNull ByteBuffer bytes,
           int readOffset,
           int length)
    throws BufferOverflowException,
           IllegalStateException
```
    Copy from ByteBuffer into this.
    Does not update cursors e.g. writePosition()
    
    Parameters:
    
    writeOffset - offset to write to
    
    bytes - copy from bytes
    
    readOffset - copy from offset
    
    length -
    
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
  - write
```
@NotNull
default R write(long offsetInRDO,
                         @NotNull
                         @NotNull BytesStore bytes)
                  throws BufferOverflowException,
                         IllegalStateException
```
    Copies whole BytesStore into this - see write(long, RandomDataInput, long, long)
    
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
  - write
```
@NotNull
R write(long writeOffset,
                 @NotNull
                 @NotNull RandomDataInput bytes,
                 long readOffset,
                 long length)
          throws BufferOverflowException,
                 BufferUnderflowException,
                 IllegalStateException
```
    Copy from RandomDataInput into this. Does not bump writePosition() nor RandomCommon.readPosition()
    
    Parameters:
    
    writeOffset - offset to write to
    
    bytes - copy from bytes
    
    readOffset - copy from offset
    
    length -
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
    
    BufferUnderflowException
  - zeroOut
```
@NotNull
R zeroOut(long start,
                   long end)
            throws IllegalStateException
```
    Zero out the bytes between the start and the end.
    
    Parameters:
    
    start - index of first byte inclusive
    
    end - index of last byte exclusive
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - if the capacity was exceeded
    
    IllegalStateException
  - append
```
@NotNull
default R append(long offset,
                          long value,
                          int digits)
                   throws BufferOverflowException,
                          IllegalArgumentException,
                          IllegalStateException
```
    Throws:
    
    BufferOverflowException
    
    IllegalArgumentException
    
    IllegalStateException
  - append
```
@NotNull
default R append(long offset,
                          double value,
                          int decimalPlaces,
                          int digits)
                   throws BufferOverflowException,
                          IllegalArgumentException,
                          IllegalStateException,
                          ArithmeticException
```
    Throws:
    
    BufferOverflowException
    
    IllegalArgumentException
    
    IllegalStateException
    
    ArithmeticException
  - nativeWrite
```
void nativeWrite(long address,
                 long position,
                 long size)
          throws BufferOverflowException,
                 IllegalStateException
```
    expert level method to copy data from native memory into the BytesStore
    
    Parameters:
    
    address - in native memory to copy from
    
    position - in BytesStore to copy to
    
    size - in bytes
    
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
  - writeUtf8
```
default long writeUtf8(long writeOffset,
                       @Nullable
                       @Nullable CharSequence text)
                throws BufferOverflowException,
                       IllegalStateException,
                       ArithmeticException
```
    Writes the provided text into this RandomDataOutput writing at the given writeOffset, in Utf8 format. Returns the new write position after writing the provided text.
    
    Parameters:
    
    writeOffset - the writeOffset to write char sequence from
    
    text - the char sequence to write, could be null
    
    Returns:
    
    the writeOffset after the char sequence written, in this RandomDataOutput
    
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
    
    ArithmeticException
    
    See Also:
    
    RandomDataInput.readUtf8(long, Appendable)
  - writeUtf8Limited
```
default long writeUtf8Limited(long writeOffset,
                              @Nullable
                              @Nullable CharSequence text,
                              int maxUtf8Len)
                       throws BufferOverflowException,
                              IllegalStateException,
                              ArithmeticException
```
    Writes the given text to this RandomDataOutput writing at the provided writeOffset, in Utf8 format, checking that the utf8 encoding size of the given char sequence is less or equal to the provided maxUtf8Len, otherwise IllegalArgumentException is thrown, and no bytes of this RandomDataOutput are overwritten. Returns the new write position after writing the provided text
    
    Parameters:
    
    writeOffset - the writeOffset to write char sequence from
    
    text - the char sequence to write, could be null
    
    maxUtf8Len - the maximum allowed length (in Utf8 encoding) of the given char sequence
    
    Returns:
    
    the writeOffset after the char sequence written, in this RandomDataOutput
    
    Throws:
    
    IllegalArgumentException - if the given char sequence size in Utf8 encoding exceeds maxUtf8Len
    
    BufferOverflowException
    
    IllegalStateException
    
    ArithmeticException
    
    See Also:
    
    RandomDataInput.readUtf8Limited(long, Appendable, int), RandomDataInput.readUtf8Limited(long, int)
  - write8bit
```
long write8bit(long position,
               @NotNull
               @NotNull BytesStore bs)
```
    Write the stop bit length and copy the BytesStore
    
    Parameters:
    
    position - to write
    
    bs - to copy.
    
    Returns:
    
    the offset after the char sequence written, in this RandomDataOutput
  - write8bit
```
long write8bit(long position,
               @NotNull
               @NotNull String s,
               int start,
               int length)
```
  - compareAndSwapInt
```
boolean compareAndSwapInt(long offset,
                          int expected,
                          int value)
                   throws BufferOverflowException,
                          IllegalStateException
```
    Perform a 32-bit CAS at a given offset.
    
    Parameters:
    
    offset - to perform CAS
    
    expected - value
    
    value - to set
    
    Returns:
    
    true, if successful.
    
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
  - testAndSetInt
```
void testAndSetInt(long offset,
                   int expected,
                   int value)
            throws BufferOverflowException,
                   IllegalStateException
```
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
  - compareAndSwapLong
```
boolean compareAndSwapLong(long offset,
                           long expected,
                           long value)
                    throws BufferOverflowException,
                           IllegalStateException
```
    Perform a 64-bit CAS at a given offset.
    
    Parameters:
    
    offset - to perform CAS
    
    expected - value
    
    value - to set
    
    Returns:
    
    true, if successful.
    
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
  - compareAndSwapFloat
```
boolean compareAndSwapFloat(long offset,
                            float expected,
                            float value)
```
    Perform a 32-bit float CAS at a given offset.
    
    Parameters:
    
    offset - to perform CAS
    
    expected - value
    
    value - to set
    
    Returns:
    
    true, if successful.
  - compareAndSwapDouble
```
boolean compareAndSwapDouble(long offset,
                             double expected,
                             double value)
```
    Perform a 64-bit double CAS at a given offset.
    
    Parameters:
    
    offset - to perform CAS
    
    expected - value
    
    value - to set
    
    Returns:
    
    true, if successful.
  - addAndGetInt
```
int addAndGetInt(long offset,
                 int adding)
```
    Perform an atomic add and get operation for a 32-bit int
    
    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
    
    IllegalStateException - if released
  - addAndGetLong
```
long addAndGetLong(long offset,
                   long adding)
```
    Perform an atomic add and get operation for a 64-bit long
    
    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
    
    IllegalStateException - if released
  - addAndGetFloat
```
float addAndGetFloat(long offset,
                     float adding)
```
    Perform an atomic add and get operation for a 32-bit float
    
    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
  - addAndGetDouble
```
double addAndGetDouble(long offset,
                       double adding)
```
    Perform an atomic add and get operation for a 64-bit double
    
    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
    
    IllegalStateException - if released
  - internalNumberBuffer
```
byte[] internalNumberBuffer()
```
  - start
```
default long start()
```
    Returns:
    
    The smallest position allowed in this buffer.
  - capacity
```
default long capacity()
```
    Returns:
    
    the highest limit allowed for this buffer.
  - realCapacity
```
default long realCapacity()
```
    Returns:
    
    the limit for this buffer without resizing
  - readPosition
```
default long readPosition()
```
    Returns the read position.
    The read position is start() <= readPosition() && readPosition() <= readLimit() && readPosition < safeLimit()
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    position to read from.
  - writePosition
```
default 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
```
default long lengthWritten(long startPosition)
```
    Typically this calculates the difference however for HexDumpBytes it's not as simple.
    If the resource is closed, the returned value is unspecified.
    
    Parameters:
    
    startPosition - to compare against
    
    Returns:
    
    the length from the startPosition
  - readRemaining
```
default long readRemaining()
```
    Returns the remaining bytes that can be read.
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    How many more bytes can we read.
  - realReadRemaining
```
default long realReadRemaining()
```
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    how much can be safely read directly.
  - writeRemaining
```
default long writeRemaining()
```
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    How many more bytes can we written.
  - realWriteRemaining
```
default long realWriteRemaining()
```
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    writeRemaining with resize
  - readLimit
```
default long readLimit()
```
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    the highest offset or position allowed for this buffer.
  - writeLimit
```
default long writeLimit()
```
    Returns the write limit.
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    the write limit
  - addressForRead
```
long addressForRead(long offset)
             throws UnsupportedOperationException,
                    BufferUnderflowException,
                    IllegalStateException
```
    Obtain the underlying addressForRead. This is for expert users only.
    
    Parameters:
    
    offset - within this buffer. addressForRead(start()) is the actual addressForRead of the first byte.
    
    Returns:
    
    the underlying addressForRead of the buffer
    
    Throws:
    
    UnsupportedOperationException - if the underlying buffer is on the heap
    
    BufferUnderflowException - if the offset is before the start() or the after the capacity()
    
    IllegalStateException
  - addressForRead
```
default long addressForRead(long offset,
                            int buffer)
                     throws UnsupportedOperationException,
                            BufferUnderflowException,
                            IllegalStateException
```
    Throws:
    
    UnsupportedOperationException
    
    BufferUnderflowException
    
    IllegalStateException
  - addressForWrite
```
long addressForWrite(long offset)
              throws UnsupportedOperationException,
                     BufferOverflowException,
                     IllegalStateException
```
    Obtain the underlying addressForRead. This is for expert users only.
    
    Parameters:
    
    offset - within this buffer. addressForRead(start()) is the actual addressForRead of the first byte.
    
    Returns:
    
    the underlying addressForRead of the buffer
    
    Throws:
    
    UnsupportedOperationException - if the underlying buffer is on the heap
    
    BufferOverflowException - if the offset is before the start() or the after the capacity()
    
    IllegalStateException
  - addressForWritePosition
```
long addressForWritePosition()
                      throws UnsupportedOperationException,
                             BufferOverflowException,
                             IllegalStateException
```
    Throws:
    
    UnsupportedOperationException
    
    BufferOverflowException
    
    IllegalStateException
  - byteOrder
```
default ByteOrder byteOrder()
```
  - bytesForRead
```
@NotNull
@NotNull Bytes<?> bytesForRead()
                                 throws IllegalStateException
```
    Returns:
    
    the streaming bytes for reading.
    
    Throws:
    
    IllegalStateException
  - bytesForWrite
```
@NotNull
@NotNull Bytes<?> bytesForWrite()
                                  throws IllegalStateException
```
    Returns:
    
    the streaming bytes for writing.
    
    Throws:
    
    IllegalStateException
  - sharedMemory
```
boolean sharedMemory()
```
    Returns:
    
    true if these Bytes use shared memory.
  - isDirectMemory
```
boolean isDirectMemory()
```

Interface RandomDataOutput<R extends RandomDataOutput<R>>

Field Summary

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

Method Summary

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

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

Method Detail

writeByte

writeUnsignedByte

writeBoolean

writeUnsignedShort

writeUnsignedInt

writeByte

writeShort

writeInt24

writeInt

writeOrderedInt

writeOrderedFloat

writeLong

writeOrderedLong

writeOrderedDouble

writeFloat

writeDouble

writeVolatileByte

writeVolatileShort

writeVolatileInt

writeVolatileLong

writeVolatileFloat

writeVolatileDouble

write

write

write

write

write

zeroOut

append

append

nativeWrite

writeUtf8

writeUtf8Limited

write8bit

write8bit

compareAndSwapInt

testAndSetInt

compareAndSwapLong

compareAndSwapFloat

compareAndSwapDouble

addAndGetInt

addAndGetLong

addAndGetFloat

addAndGetDouble

internalNumberBuffer

start

capacity

realCapacity

readPosition

writePosition

lengthWritten

readRemaining

realReadRemaining

writeRemaining

realWriteRemaining

readLimit

writeLimit

addressForRead

addressForRead

addressForWrite

addressForWritePosition

byteOrder

bytesForRead

bytesForWrite

sharedMemory

isDirectMemory