WrappedBytes (OpenHFT/Java-Lang/lang 6.8.19-SNAPSHOT API)

java.lang.Object
- net.openhft.lang.io.WrappedBytes<B>

All Implemented Interfaces:

DataInput, DataOutput, ObjectInput, ObjectOutput, Appendable, AutoCloseable, CharSequence, RandomAccess, Bytes, BytesCommon, BytesStore, ByteStringAppender, ByteStringParser, RandomDataInput, RandomDataOutput, RandomDataUpdate, BytesMarshallable, ReferenceCounted
```
public abstract class WrappedBytes<B extends Bytes>
extends Object
implements Bytes
```
A super class for those which wrap bytes.

Field Summary

Fields
Modifier and Type Field and Description

protected B wrapped

Fields
Modifier and Type	Field and Description
`protected B`	`wrapped`

Constructor Summary

Constructors
Modifier Constructor and Description

protected WrappedBytes(B wrapped)

Constructors
Modifier	Constructor and Description
`protected`	`WrappedBytes(B wrapped)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`addAndGetInt(long offset, int delta)` Atomically adds the given value to the current value.
`double`	`addAtomicDouble(long offset, double d)`
`float`	`addAtomicFloat(long offset, float f)`
`int`	`addAtomicInt(long offset, int i)`
`long`	`addAtomicLong(long offset, long l)`
`byte`	`addByte(long offset, byte b)`
`double`	`addDouble(long offset, double d)`
`float`	`addFloat(long offset, float f)`
`int`	`addInt(long offset, int i)`
`long`	`addLong(long offset, long i)`
`long`	`address()`
`short`	`addShort(long offset, short s)`
`int`	`addUnsignedByte(long offset, int i)`
`long`	`addUnsignedInt(long offset, long i)`
`int`	`addUnsignedShort(long offset, int i)`
`void`	`alignPositionAddr(int alignment)` Align the position address to a power of 2.
`ByteStringAppender`	`append(boolean b)` Writes "true" or "false".
`ByteStringAppender`	`append(char c)`
`ByteStringAppender`	`append(CharSequence s)`
`ByteStringAppender`	`append(CharSequence s, int start, int end)`
`ByteStringAppender`	`append(double d)`
`ByteStringAppender`	`append(double d, int precision)`
`ByteStringAppender`	`append(Enum value)`
`ByteStringAppender`	`append(int i)`
`<E> ByteStringAppender`	`append(Iterable<E> list, CharSequence separator)`
`ByteStringAppender`	`append(long l)`
`ByteStringAppender`	`append(long l, int base)`
`ByteStringAppender`	`append(MutableDecimal md)`
`ByteStringAppender`	`appendDateMillis(long timeInMS)`
`ByteStringAppender`	`appendDateTimeMillis(long timeInMS)`
`ByteStringAppender`	`appendTimeMillis(long timeInMS)`
`CharSequence`	`asString()` Dump the contents of Bytes as a CharSequence
`void`	`asString(Appendable appendable)` Dump the contents of this Bytes as text in the Appendable.
`int`	`available()`
`void`	`busyLockInt(long offset)` Lock which uses 4 bytes.
`void`	`busyLockLong(long offset)` Lock across processes
`ByteOrder`	`byteOrder()`
`Bytes`	`bytes()` Create a bytes whose content is the whole bytes store.
`Bytes`	`bytes(long offset, long length)` Slice a `Bytes` object with start address of `address+ offset` and capacity of `length`.
`long`	`capacity()`
`char`	`charAt(int index)`
`void`	`checkEndOfBuffer()`
`Bytes`	`clear()` Clears this buffer.
`void`	`clearThreadAssociation()` Needed if the buffer is created in one thread and used in another.
`void`	`close()` Finishes the excerpt entry if not finished()
`boolean`	`compare(long offset, RandomDataInput input, long inputOffset, long len)`
`boolean`	`compareAndSwapDouble(long offset, double expected, double x)` Perform a compare and set operation.
`boolean`	`compareAndSwapInt(long offset, int expected, int x)` Perform a compare and set operation.
`boolean`	`compareAndSwapLong(long offset, long expected, long x)` Perform a compare and set operation.
`File`	`file()`
`void`	`finish()` Mark the end of the message if writing and check we are at the end of the message if reading.
`Bytes`	`flip()` Flips this buffer.
`void`	`flush()` Check the end of the stream has not overflowed.
`void`	`free()`
`int`	`getAndAdd(long offset, int delta)` Atomically adds the given value to the current value.
`InputStream`	`inputStream()`
`boolean`	`isFinished()`
`int`	`length()`
`long`	`limit()`
`Bytes`	`limit(long limit)`
`Bytes`	`load()` Access every page to ensure those pages are in memory.
`ObjectSerializer`	`objectSerializer()`
`OutputStream`	`outputStream()`
`Boolean`	`parseBoolean(StopCharTester tester)` Return true or false, or null if it could not be detected as true or false.
`MutableDecimal`	`parseDecimal(MutableDecimal decimal)`
`double`	`parseDouble()`
`<E extends Enum<E>> E`	`parseEnum(Class<E> eClass, StopCharTester tester)`
`long`	`parseLong()`
`long`	`parseLong(int base)`
`String`	`parseUtf8(StopCharTester tester)`
`void`	`parseUtf8(StringBuilder builder, StopCharTester tester)` Populate a StringBuilder with the UTF encoded text until the end.
`long`	`position()`
`Bytes`	`position(long position)`
`int`	`read()` Reads a byte of data.
`int`	`read(byte[] byteArray)` Reads into an array of bytes.
`int`	`read(byte[] byteArray, int off, int len)` Reads into an array of bytes.
`void`	`read(ByteBuffer bb)` Copy bytes into a ByteBuffer to the minimum of the length `remaining()` in the ByteBuffer or the Excerpt.
`void`	`read(ByteBuffer bb, int length)` Copy bytes into a ByteBuffer to the minimum of the length in the ByteBuffer or the Excerpt.
`boolean`	`read8bitText(StringBuilder stringBuilder)`
`boolean`	`readBoolean()` Reads one input byte and returns `true` if that byte is nonzero, `false` if that byte is zero.
`boolean`	`readBoolean(long offset)` Reads one input byte and returns `true` if that byte is nonzero, `false` if that byte is zero.
`byte`	`readByte()` Reads and returns one input byte.
`byte`	`readByte(long offset)` Reads and returns one input byte.
`char`	`readChar()` Reads two input bytes and returns a `char` value.
`char`	`readChar(long offset)` Reads two input bytes and returns a `char` value.
`double`	`readCompactDouble()` Reads the first four bytes as readFloat().
`int`	`readCompactInt()` Reads two or six input bytes and returns an `int` value.
`long`	`readCompactLong()` Reads four or twelve input bytes and returns a `long` value.
`short`	`readCompactShort()` Reads one or three input bytes and returns a `short` value.
`long`	`readCompactUnsignedInt()` Reads two or six input bytes and returns an `int` value.
`int`	`readCompactUnsignedShort()` Reads one or three input bytes and returns a `short` value.
`double`	`readDouble()` Reads eight input bytes and returns a `double` value.
`double`	`readDouble(long offset)` Reads eight input bytes and returns a `double` value.
`<E> E`	`readEnum(Class<E> eClass)` Read a String with `readUTFΔ` which is converted to an enumerable type.
`<E> E`	`readEnum(long offset, int maxSize, Class<E> eClass)`
`float`	`readFloat()` Reads four input bytes and returns a `float` value.
`float`	`readFloat(long offset)` Reads four input bytes and returns a `float` value.
`void`	`readFully(byte[] byteArray)` Reads some bytes from an input stream and stores them into the buffer array `b`.
`void`	`readFully(byte[] byteArray, int off, int len)` Reads `len` bytes from an input stream.
`void`	`readFully(char[] data)`
`void`	`readFully(char[] data, int off, int len)`
`void`	`readFully(long offset, byte[] byteArray, int off, int len)`
`long`	`readIncompleteLong(long offset)` Same as readLong except the remaining() can be less than 8.
`<T> T`	`readInstance(Class<T> objClass, T obj)` Read an instance of a class assuming objClass was provided when written.
`int`	`readInt()` Reads four input bytes and returns an `int` value.
`int`	`readInt(long offset)` Reads four input bytes and returns an `int` value.
`int`	`readInt24()` Reads three input bytes and returns a 24-bit `int` value.
`int`	`readInt24(long offset)` Reads three input bytes and returns a 24-bit `int` value.
`long`	`readInt48()` Reads six input bytes and returns a `long` value.
`long`	`readInt48(long offset)` Reads six input bytes and returns a `long` value.
`String`	`readLine()` Reads the next line of text from the input stream.
`<E> void`	`readList(Collection<E> list, Class<E> eClass)` Read a stop bit encoded length and populates this Collection after zeroOut()ing it.
`long`	`readLong()` Reads eight input bytes and returns a `long` value.
`long`	`readLong(long offset)` Reads eight input bytes and returns a `long` value.
`<K,V> Map<K,V>`	`readMap(Map<K,V> map, Class<K> kClass, Class<V> vClass)` Read a stop bit encoded length and populates this Map after zeroOut()ing it.
`void`	`readMarshallable(Bytes in)` read an object from bytes
`Object`	`readObject()` Read and return an object.
`<T> T`	`readObject(Class<T> tClass)` Read and return an object.
`void`	`readObject(Object object, int start, int end)` Read the object from start to end bytes
`short`	`readShort()` Reads two input bytes and returns a `short` value.
`short`	`readShort(long offset)` Reads two input bytes and returns a `short` value.
`long`	`readStopBit()` Reads between one and ten bytes with are stop encoded with support for negative numbers
`int`	`readUnsignedByte()` Reads one input byte, zero-extends it to type `int`, and returns the result, which is therefore in the range `0` through `255`.
`int`	`readUnsignedByte(long offset)` Reads one input byte, zero-extends it to type `int`, and returns the result, which is therefore in the range `0` through `255`.
`int`	`readUnsignedByteOrThrow()`
`long`	`readUnsignedInt()` Reads four input bytes and returns an `int` value.
`long`	`readUnsignedInt(long offset)` Reads four input bytes and returns an `int` value.
`int`	`readUnsignedShort()` Reads two input bytes and returns an `int` value in the range `0` through `65535`.
`int`	`readUnsignedShort(long offset)` Reads two input bytes and returns an `int` value in the range `0` through `65535`.
`String`	`readUTF()` Reads in a string that has been encoded using a modified UTF-8 format.
`String`	`readUTFΔ()` The same as readUTF() except the length is stop bit encoded.
`String`	`readUTFΔ(long offset)` The same as readUTFΔ() except an offset is given.
`boolean`	`readUTFΔ(StringBuilder stringBuilder)` The same as readUTFΔ() except the chars are copied to a truncated StringBuilder.
`double`	`readVolatileDouble(long offset)` This is the same as readDouble() except a read barrier is performed first.
`float`	`readVolatileFloat(long offset)` This is the same as readFloat() except a read barrier is performed first.
`int`	`readVolatileInt()` This is the same as readInt() except a read barrier is performed first.
`int`	`readVolatileInt(long offset)` This is the same as readInt() except a read barrier is performed first.
`long`	`readVolatileLong()` This is the same readLong() except a dread barrier is performed first
`long`	`readVolatileLong(long offset)` This is the same readLong() except a dread barrier is performed first
`int`	`refCount()`
`boolean`	`release()`
`long`	`remaining()`
`void`	`reserve()`
`void`	`resetLockInt(long offset)` Lock which uses 4 bytes.
`void`	`resetLockLong(long offset)` Lock which uses 8 bytes.
`boolean`	`selfTerminating()`
`void`	`selfTerminating(boolean selfTerminate)` If set to true, the end of the Bytes will be the end of any consuming String, double or long.
`long`	`size()`
`long`	`skip(long n)` Skips n bytes of input.
`int`	`skipBytes(int n)` Makes an attempt to skip over `n` bytes of data from the input stream, discarding the skipped bytes.
`boolean`	`skipTo(StopCharTester tester)` Wind from this positionAddr to the end of the field
`Bytes`	`slice()` Creates a new bytes whose content is a shared subsequence of this bytes' content.
`Bytes`	`slice(long offset, long length)` Creates a new bytes whose content is a shared subsequence of this bytes' content.
`ByteBuffer`	`sliceAsByteBuffer(ByteBuffer toReuse)` Returns a `ByteBuffer` whose content is a shared subsequence of this bytes' content.
`boolean`	`startsWith(RandomDataInput keyBytes)`
`boolean`	`stepBackAndSkipTo(StopCharTester tester)` Make sure we just read a stop character
`CharSequence`	`subSequence(int start, int end)`
`int`	`threadIdForLockInt(long offset)` Lock which uses 4 bytes.
`long`	`threadIdForLockLong(long offset)` Lock which uses 8 bytes.
`String`	`toDebugString()`
`String`	`toDebugString(long limit)`
`String`	`toHexString(long limit)`
`void`	`toString(Appendable sb, long start, long position, long end)` Write a portion of the Bytes to an Appendable for printing.
`boolean`	`tryLockInt(long offset)` Lock which uses 4 bytes.
`boolean`	`tryLockLong(long offset)` Lock across processes
`boolean`	`tryLockNanosInt(long offset, long nanos)` Lock which uses 4 bytes.
`boolean`	`tryLockNanosLong(long offset, long nanos)` Lock across processes
`boolean`	`tryRWReadLock(long offset, long timeOutNS)` Uses the 64-bit long at the offset as a non-reentrant read/write lock.
`boolean`	`tryRWWriteLock(long offset, long timeOutNS)` Uses the 64-bit long at the offset as a non-reentrant read/write lock.
`void`	`unlockInt(long offset)` Lock which uses 4 bytes.
`void`	`unlockLong(long offset)` Lock across processes
`void`	`unlockRWReadLock(long offset)` Uses the 64-bit long at the offset as a non-reentrant read/write lock.
`void`	`unlockRWWriteLock(long offset)` Uses the 64-bit long at the offset as a non-reentrant read/write lock.
`void`	`write(byte[] byteArray)` Writes to the output stream all the bytes in array `bytes`.
`void`	`write(byte[] byteArray, int off, int len)` Writes `len` bytes from array `bytes`, in order, to the output stream.
`void`	`write(Byteable byteable)` Copies the contents of a Byteable from the offset for maxSize bytes, moves the position of "this" RandomDataOutput by the maxSize
`void`	`write(ByteBuffer bb)` Copies the contents of a ByteBuffer from the position to the limit.
`void`	`write(char[] data)`
`void`	`write(char[] data, int off, int len)`
`void`	`write(int b)` Writes to the output stream the eight low-order bits of the argument `b`.
`void`	`write(long offset, byte[] byteArray)` Writes to the output stream all the bytes in array `bytes`.
`void`	`write(long offset, byte[] byteArray, int off, int len)`
`void`	`write(long offset, Bytes bytes)`
`void`	`write(RandomDataInput in)` Copies the contents of a RandomDataInput from the position to the limit.
`void`	`write(RandomDataInput in, long position, long length)` Copy from one Bytes to another, moves the position of "this" RandomDataOutput by the length.
`void`	`write8bitText(CharSequence s)`
`void`	`writeBoolean(boolean v)` Writes a `boolean` value to this output stream.
`void`	`writeBoolean(long offset, boolean v)` Writes a `boolean` value to this output stream.
`void`	`writeByte(int v)` Writes to the output stream the eight low- order bits of the argument `v`.
`void`	`writeByte(long offset, int b)` Writes to the output stream the eight low-order bits of the argument `b`.
`void`	`writeBytes(String s)` Writes a string to the output stream.
`void`	`writeChar(int v)` Writes a `char` value, which is comprised of two bytes, to the output stream.
`void`	`writeChar(long offset, int v)` Writes a `char` value, which is comprised of two bytes, to the output stream.
`void`	`writeChars(CharSequence cs)` Writes chars of the given `CharSequence` to the bytes, without encoding.
`void`	`writeChars(String s)` Writes every character in the string `s`, to the output stream, in order, two bytes per character.
`void`	`writeCompactDouble(double v)` Writes four or twelve bytes as follow;
`void`	`writeCompactInt(int v)` Writes two or six bytes as follows; Integer.MIN_VALUE => Short.MIN_VALUE, Integer.MAX_VALUE => Short.MAX_VALUE, Short.MIN_VALUE+2 to Short.MAX_VALUE-1 => writeShort(x), default => writeShort(Short.MIN_VALUE+1; writeInt(x)
`void`	`writeCompactLong(long v)` Writes four or twelve bytes as follows Long.MIN_VALUE => Integer.MIN_VALUE, Long.MAX_VALUE => Integer.MAX_VALUE, Integer.MIN_VALUE+2 to Integer.MAX_VALUE-1 => writeInt(x), default => writeInt(Integer.MIN_VALUE+1; writeLong(x)
`void`	`writeCompactShort(int v)` Writes one or three bytes as follows; Short.MIN_VALUE => Byte.MIN_VALUE, Short.MAX_VALUE => Byte.MAX_VALUE, Short.MIN_VALUE+2 to Short.MAX_VALUE-1 => writeByte(x), default => writeByte(Byte.MIN_VALUE+1; writeShort(x)
`void`	`writeCompactUnsignedInt(long v)` Writes two or six bytes as follows; 0 to (1 << 16) - 2 => writeInt(x), otherwise writeShort(-1); writeInt(x)
`void`	`writeCompactUnsignedShort(int v)` Writes one or three bytes as follows; 0 to 254 => writeByte(x); otherwise writeByte(255); writeByteShort(x);
`void`	`writeDouble(double v)` Writes a `double` value, which is comprised of eight bytes, to the output stream.
`void`	`writeDouble(long offset, double v)` Writes a `double` value, which is comprised of eight bytes, to the output stream.
`<E> void`	`writeEnum(E e)` Write the object in a form which can be uniquely recreated by readEnum.
`void`	`writeEnum(long offset, int len, Object object)`
`void`	`writeFloat(float v)` Writes a `float` value, which is comprised of four bytes, to the output stream.
`void`	`writeFloat(long offset, float v)` Writes a `float` value, which is comprised of four bytes, to the output stream.
`<OBJ> void`	`writeInstance(Class<OBJ> objClass, OBJ obj)` Write an object with the assumption that the objClass will be provided when the class is read.
`void`	`writeInt(int v)` Writes an `int` value, which is comprised of four bytes, to the output stream.
`void`	`writeInt(long offset, int v)` Writes an `int` value, which is comprised of four bytes, to the output stream.
`void`	`writeInt24(int v)` Writes an `int` value, which is comprised of three bytes, to the output stream.
`void`	`writeInt24(long offset, int v)` Writes an `int` value, which is comprised of three bytes, to the output stream.
`void`	`writeInt48(long v)` Writes a `long` value, which is comprised of eight bytes, to the output stream.
`void`	`writeInt48(long offset, long v)` Writes a `long` value, which is comprised of eight bytes, to the output stream.
`<E> void`	`writeList(Collection<E> list)` Write an ordered collection of "enumerable objects" (See writeEnum).
`void`	`writeLong(long v)` Writes a `long` value, which is comprised of eight bytes, to the output stream.
`void`	`writeLong(long offset, long v)` Writes a `long` value, which is comprised of eight bytes, to the output stream.
`<K,V> void`	`writeMap(Map<K,V> map)` Write the keys and values of a Map of "enumerable objects" (See writeEnum).
`void`	`writeMarshallable(Bytes out)` write an object to bytes
`void`	`writeObject(Object object)` Write an object as either an "enumerable object" or a Serializable/Externalizable object using Java Serialization.
`void`	`writeObject(Object object, int start, int end)` Copy data from an Object from bytes start to end.
`void`	`writeOrderedDouble(long offset, double v)` Same as writeDouble but include an ordered write barrier.
`void`	`writeOrderedFloat(long offset, float v)` Same as writeFloat but include an ordered write barrier.
`void`	`writeOrderedInt(int v)` Same as writeInt but include an ordered write barrier.
`void`	`writeOrderedInt(long offset, int v)` Same as writeInt but include an ordered write barrier.
`void`	`writeOrderedLong(long v)` Same as writeLong but include an ordered write barrier.
`void`	`writeOrderedLong(long offset, long v)` Same as writeLong but include an ordered write barrier.
`void`	`writeShort(int v)` Writes two bytes to the output stream to represent the value of the argument.
`void`	`writeShort(long offset, int v)` Writes two bytes to the output stream to represent the value of the argument.
`void`	`writeStopBit(long n)` Stop bit encoding numbers.
`void`	`writeUnsignedByte(int v)` Writes to the output stream the eight low- order bits of the argument `v`.
`void`	`writeUnsignedByte(long offset, int v)` Writes to the output stream the eight low- order bits of the argument `v`.
`void`	`writeUnsignedInt(long v)` Writes an `int` value, which is comprised of four bytes, to the output stream.
`void`	`writeUnsignedInt(long offset, long v)` Writes an `int` value, which is comprised of four bytes, to the output stream.
`void`	`writeUnsignedShort(int v)` Writes two bytes to the output stream to represent the value of the argument.
`void`	`writeUnsignedShort(long offset, int v)` Writes two bytes to the output stream to represent the value of the argument.
`void`	`writeUTF(String s)` Writes two bytes of length information to the output stream, followed by the modified UTF-8 representation of every character in the string `s`.
`void`	`writeUTFΔ(CharSequence s)` Write the same encoding as `writeUTF` with the following changes.
`void`	`writeUTFΔ(long offset, int maxSize, CharSequence s)` Write the same encoding as `writeUTF` with the following changes.
`Bytes`	`zeroOut()` fill the Bytes with zeros, and clear the position.
`Bytes`	`zeroOut(long start, long end)` fill the Bytes with zeros.
`Bytes`	`zeroOut(long start, long end, boolean ifNotZero)` fill the Bytes with zeros, and clear the position, avoiding touching pages unnecessarily

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

Methods inherited from interface net.openhft.lang.io.RandomDataInput
nextSetBit

Methods inherited from interface java.lang.CharSequence
chars, codePoints, toString

- Field Detail
  - wrapped
```
protected B extends Bytes wrapped
```
- Constructor Detail
  - WrappedBytes
```
protected WrappedBytes(B wrapped)
```
- Method Detail
  - clearThreadAssociation
```
public void clearThreadAssociation()
```
    Description copied from interface: Bytes
    
    Needed if the buffer is created in one thread and used in another.
    
    Specified by:
    
    clearThreadAssociation in interface Bytes
  - sliceAsByteBuffer
```
public ByteBuffer sliceAsByteBuffer(@Nullable
                                    ByteBuffer toReuse)
```
    Description copied from interface: BytesCommon
    
    Returns a ByteBuffer whose content is a shared subsequence of this bytes' content.
    The content of the returned ByteBuffer will start at this bytes' current position. Changes to this bytes' content will be visible in the returned ByteBuffer, and vice versa; this bytes' and the returned ByteBuffer's position and limit values will be independent.
    The returned ByteBuffer's position will be zero, its capacity and its limit will be the number of bytes remaining in this bytes.
    If this bytes object is able to reuse to given toReuse ByteBuffer, it will be reused and returned back from this method, otherwise a new ByteBuffer instance is created and returned.
    
    Specified by:
    
    sliceAsByteBuffer in interface BytesCommon
    
    Parameters:
    
    toReuse - a ByteBuffer to reuse
    
    Returns:
    
    a ByteBuffer view of this Bytes
    
    See Also:
    
    BytesCommon.slice(), ByteBuffer.slice()
  - readMarshallable
```
public void readMarshallable(@NotNull
                             Bytes in)
                      throws IllegalStateException
```
    Description copied from interface: BytesMarshallable
    
    read an object from bytes
    
    Specified by:
    
    readMarshallable in interface BytesMarshallable
    
    Parameters:
    
    in - to read from
    
    Throws:
    
    IllegalStateException - if the object could not be read.
  - toDebugString
```
public String toDebugString(long limit)
```
    Specified by:
    
    toDebugString in interface BytesCommon
  - toHexString
```
public String toHexString(long limit)
```
    Specified by:
    
    toHexString in interface BytesCommon
  - compare
```
public boolean compare(long offset,
                       RandomDataInput input,
                       long inputOffset,
                       long len)
```
    Specified by:
    
    compare in interface RandomDataInput
  - readCompactLong
```
public long readCompactLong()
```
    Description copied from interface: RandomDataInput
    
    Reads four or twelve input bytes and returns a long value. Let a be the first int read with readInt(). This mapped as follows; Integer.MIN_VALUE => Long.MIN_VALUE, Integer.MAX_VALUE => Long.MAX_VALUE, Integer.MIN_VALUE+2 to Integer.MAX_VALUE-1 => same as short value, Integer.MIN_VALUE+1 => readLong().
    This method is suitable for reading the bytes written by the writeCompactLong method of interface RandomDataOutput.
    
    Specified by:
    
    readCompactLong in interface RandomDataInput
    
    Returns:
    
    the 64-bit value read.
  - tryLockNanosInt
```
public boolean tryLockNanosInt(long offset,
                               long nanos)
```
    Description copied from interface: RandomDataUpdate
    
    Lock which uses 4 bytes. It store the lower 24 bits of the Thread Id and the re-entrant count as 8 bit. This means if you create more than 16 million threads you can get a collision, and if you try to re-enter 255 times you will get an ISE
    
    Specified by:
    
    tryLockNanosInt in interface RandomDataUpdate
    
    Parameters:
    
    offset - of the start of the 4-byte lock
    
    nanos - to try to lock for
    
    Returns:
    
    did it lock or not.
  - writeMarshallable
```
public void writeMarshallable(@NotNull
                              Bytes out)
```
    Description copied from interface: BytesMarshallable
    
    write an object to bytes
    
    Specified by:
    
    writeMarshallable in interface BytesMarshallable
    
    Parameters:
    
    out - to write to
  - readInt24
```
public int readInt24()
```
    Description copied from interface: RandomDataInput
    Reads three input bytes and returns a 24-bit int value. Let a-c be the first through third bytes read on big endian machines, and the opposite on little endian machines. The value returned is:
```
 
 ((((a & 0xff) << 24) | ((b & 0xff) << 16) | ((c & 0xff) << 8))) >> 8
 
```
    This method is suitable for reading bytes written by the writeInt24 method of interface RandomDataOutput.
    Specified by:
    
    readInt24 in interface RandomDataInput
    
    Returns:
    
    the int value read.
  - flush
```
public void flush()
```
    Description copied from interface: RandomDataOutput
    
    Check the end of the stream has not overflowed. Otherwise this doesn't do anything.
    
    Specified by:
    
    flush in interface ObjectOutput
    
    Specified by:
    
    flush in interface RandomDataOutput
  - writeDouble
```
public void writeDouble(long offset,
                        double v)
```
    Description copied from interface: RandomDataOutput
    
    Writes a double value, which is comprised of eight bytes, to the output stream. It does this as if it first converts this double value to a long in exactly the manner of the Double.doubleToLongBits method and then writes the long value in exactly the manner of the writeLong method. The bytes written by this method may be read by the readDouble method of interface DataInput, which will then return a double equal to v.
    
    Specified by:
    
    writeDouble in interface RandomDataOutput
    
    Parameters:
    
    offset - to write to
    
    v - the double value to be written.
  - limit
```
public long limit()
```
    Specified by:
    
    limit in interface BytesCommon
    
    Returns:
    
    the current limit which must be >= capacity()
  - appendTimeMillis
```
@NotNull
public ByteStringAppender appendTimeMillis(long timeInMS)
```
    Specified by:
    
    appendTimeMillis in interface ByteStringAppender
  - parseEnum
```
@Nullable
public <E extends Enum<E>> E parseEnum(@NotNull
                                                 Class<E> eClass,
                                                 @NotNull
                                                 StopCharTester tester)
                                          throws BufferUnderflowException
```
    Specified by:
    
    parseEnum in interface ByteStringParser
    
    Throws:
    
    BufferUnderflowException
  - refCount
```
public int refCount()
```
    Specified by:
    
    refCount in interface ReferenceCounted
  - writeShort
```
public void writeShort(long offset,
                       int v)
```
    Description copied from interface: RandomDataOutput
    Writes two bytes to the output stream to represent the value of the argument. The byte values to be written, in the order shown for big endian machines and the opposite for little endian, are:
```
 (byte)(0xff & (v >> 8))
 (byte)(0xff & v)
  
```
    The bytes written by this method may be read by the readShort method of interface DataInput , which will then return a short equal to (short)v.
    Specified by:
    
    writeShort in interface RandomDataOutput
    
    Parameters:
    
    offset - to be written to
    
    v - the short value to be written.
  - writeEnum
```
public <E> void writeEnum(@Nullable
                          E e)
```
    Description copied from interface: RandomDataOutput
    
    Write the object in a form which can be uniquely recreated by readEnum. This type of "enumerable objects" has the following constraints; 1) each object must have a one to one mapping with a toString() representation, 2) be immutable, 3) ideally appears more than once, 4) Must have a constructor which takes a single String or a valueOf(String) method.
    
    Specified by:
    
    writeEnum in interface RandomDataOutput
    
    Type Parameters:
    
    E - element class
    
    Parameters:
    
    e - to enumerate
  - append
```
@NotNull
public <E> ByteStringAppender append(@NotNull
                                              Iterable<E> list,
                                              @NotNull
                                              CharSequence separator)
```
    Specified by:
    
    append in interface ByteStringAppender
  - writeCompactUnsignedShort
```
public void writeCompactUnsignedShort(int v)
```
    Description copied from interface: RandomDataOutput
    
    Writes one or three bytes as follows; 0 to 254 => writeByte(x); otherwise writeByte(255); writeByteShort(x);
    The bytes written by this method may be read by the readCompactUnsignedShort method of interface RandomDataInput , which will then return a short equal to v & 0xFFFF.
    
    Specified by:
    
    writeCompactUnsignedShort in interface RandomDataOutput
    
    Parameters:
    
    v - the unsigned short value to be written.
  - readVolatileLong
```
public long readVolatileLong()
```
    Description copied from interface: RandomDataInput
    This is the same readLong() except a dread barrier is performed first
    Reads eight input bytes and returns a long value. Let a-h be the first through eighth bytes read on big endian machines, and the opposite on little endian machines. The value returned is:
```
 
 (((long)(a & 0xff) << 56) |
  ((long)(b & 0xff) << 48) |
  ((long)(c & 0xff) << 40) |
  ((long)(d & 0xff) << 32) |
  ((long)(e & 0xff) << 24) |
  ((long)(f & 0xff) << 16) |
  ((long)(g & 0xff) <<  8) |
  ((long)(h & 0xff)))
 
```
    This method is suitable for reading bytes written by the writeOrderedLong or writeVolatileLong method of interface RandomDataOutput.
    Specified by:
    
    readVolatileLong in interface RandomDataInput
    
    Returns:
    
    the long value read.
  - write
```
public void write(RandomDataInput in,
                  long position,
                  long length)
```
    Description copied from interface: RandomDataOutput
    
    Copy from one Bytes to another, moves the position of "this" RandomDataOutput by the length. The position of the RandomDataInput is not used or altered.
    
    Specified by:
    
    write in interface RandomDataOutput
    
    Parameters:
    
    in - to copy
    
    position - to copy from
    
    length - to copy
  - write
```
public void write(Byteable byteable)
```
    Description copied from interface: RandomDataOutput
    
    Copies the contents of a Byteable from the offset for maxSize bytes, moves the position of "this" RandomDataOutput by the maxSize
    
    Specified by:
    
    write in interface RandomDataOutput
    
    Parameters:
    
    byteable - to copy
  - writeOrderedInt
```
public void writeOrderedInt(int v)
```
    Description copied from interface: RandomDataOutput
    
    Same as writeInt but include an ordered write barrier. This means all writes will be visible on a read barrier if this write is visible. This might not be visible to be same thread for some clock cycles so an immediate read could see an old value
    This is much faster than a volatile write which stalls the pipeline. The data is visible to other threads at the same time.
    
    Specified by:
    
    writeOrderedInt in interface RandomDataOutput
    
    Parameters:
    
    v - value to write
  - readUTFΔ
```
public boolean readUTFΔ(@NotNull
                        StringBuilder stringBuilder)
```
    Description copied from interface: RandomDataInput
    
    The same as readUTFΔ() except the chars are copied to a truncated StringBuilder.
    
    Specified by:
    
    readUTFΔ in interface RandomDataInput
    
    Parameters:
    
    stringBuilder - to copy chars to
    
    Returns:
    
    true if there was a String, or false if it was null
  - writeInt48
```
public void writeInt48(long offset,
                       long v)
```
    Description copied from interface: RandomDataOutput
    Writes a long value, which is comprised of eight bytes, to the output stream. The byte values to be written, in the order shown for big endian machines and the opposite for little endian, are:
```
 (byte)(0xff & (v >> 40))
 (byte)(0xff & (v >> 32))
 (byte)(0xff & (v >> 24))
 (byte)(0xff & (v >> 16))
 (byte)(0xff & (v >>  8))
 (byte)(0xff & v)
 
```
    The bytes written by this method may be read by the readInt48 method of interface RandomDataInput , which will then return a long equal to v & ((1L << 48) - 1).
    Specified by:
    
    writeInt48 in interface RandomDataOutput
    
    Parameters:
    
    offset - to be written to
    
    v - the long value to be written.
  - readLong
```
public long readLong()
```
    Description copied from interface: RandomDataInput
    Reads eight input bytes and returns a long value. Let a-h be the first through eighth bytes read on big endian machines, and the opposite on little endian machines. The value returned is:
```
 
 (((long)(a & 0xff) << 56) |
  ((long)(b & 0xff) << 48) |
  ((long)(c & 0xff) << 40) |
  ((long)(d & 0xff) << 32) |
  ((long)(e & 0xff) << 24) |
  ((long)(f & 0xff) << 16) |
  ((long)(g & 0xff) <<  8) |
  ((long)(h & 0xff)))
 
```
    This method is suitable for reading bytes written by the writeLong method of interface DataOutput.
    Specified by:
    
    readLong in interface DataInput
    
    Specified by:
    
    readLong in interface RandomDataInput
    
    Returns:
    
    the long value read.
  - readIncompleteLong
```
public long readIncompleteLong(long offset)
```
    Description copied from interface: RandomDataInput
    
    Same as readLong except the remaining() can be less than 8.
    
    Specified by:
    
    readIncompleteLong in interface RandomDataInput
    
    Parameters:
    
    offset - base
    
    Returns:
    
    long.
  - writeLong
```
public void writeLong(long v)
```
    Description copied from interface: RandomDataOutput
    Writes a long value, which is comprised of eight bytes, to the output stream. The byte values to be written, in the order shown for big endian machines and the opposite for little endian, are:
```
 (byte)(0xff & (v >> 56))
 (byte)(0xff & (v >> 48))
 (byte)(0xff & (v >> 40))
 (byte)(0xff & (v >> 32))
 (byte)(0xff & (v >> 24))
 (byte)(0xff & (v >> 16))
 (byte)(0xff & (v >>  8))
 (byte)(0xff & v)
 
```
    The bytes written by this method may be read by the readLong method of interface DataInput , which will then return a long equal to v.
    Specified by:
    
    writeLong in interface DataOutput
    
    Specified by:
    
    writeLong in interface RandomDataOutput
    
    Parameters:
    
    v - the long value to be written.
  - appendDateTimeMillis
```
@NotNull
public ByteStringAppender appendDateTimeMillis(long timeInMS)
```
    Specified by:
    
    appendDateTimeMillis in interface ByteStringAppender
  - readEnum
```
@Nullable
public <E> E readEnum(@NotNull
                                Class<E> eClass)
```
    Description copied from interface: RandomDataInput
    
    Read a String with readUTFΔ which is converted to an enumerable type. i.e. where there is a one to one mapping between an object and it's toString().
    This is suitable to read an object written using writeEnum() in the RandomDataOutput interface
    
    Specified by:
    
    readEnum in interface RandomDataInput
    
    Type Parameters:
    
    E - the enum class
    
    Parameters:
    
    eClass - to decode the String as
    
    Returns:
    
    the decoded value. null with be return if null was written.
  - write
```
public void write(RandomDataInput in)
```
    Description copied from interface: RandomDataOutput
    Copies the contents of a RandomDataInput from the position to the limit.
    This method transfers the bytes remaining in the given source buffer into this buffer. If there are more bytes remaining in the source buffer than in this buffer, that is, if src.remaining() > remaining(), then no bytes are transferred and a BufferOverflowException is thrown.
    Otherwise, this method copies n = src.remaining() bytes from the given buffer into this buffer, starting at each buffer's current position. The positions of both buffers are then incremented by n.
    In other words, an invocation of this method of the form dst.write(src) has exactly the same effect as the loop
```
     while (src.hasRemaining())
         dst.writeByte(src.readByte());
  
```
    Specified by:
    
    write in interface RandomDataOutput
    
    Parameters:
    
    in - to copy
  - append
```
@NotNull
public ByteStringAppender append(double d)
```
    Specified by:
    
    append in interface ByteStringAppender
  - toDebugString
```
@NotNull
public String toDebugString()
```
    Specified by:
    
    toDebugString in interface BytesCommon
  - isFinished
```
public boolean isFinished()
```
    Specified by:
    
    isFinished in interface BytesCommon
    
    Returns:
    
    has finish been called.
  - writeCompactUnsignedInt
```
public void writeCompactUnsignedInt(long v)
```
    Description copied from interface: RandomDataOutput
    
    Writes two or six bytes as follows; 0 to (1 << 16) - 2 => writeInt(x), otherwise writeShort(-1); writeInt(x)
    The bytes written by this method may be read by the readCompactUnsignedInt method of interface RandomDataInput , which will then return a int equal to v & 0xFFFFFFFF.
    
    Specified by:
    
    writeCompactUnsignedInt in interface RandomDataOutput
    
    Parameters:
    
    v - the short value to be written.
  - append
```
@NotNull
public ByteStringAppender append(double d,
                                          int precision)
```
    Specified by:
    
    append in interface ByteStringAppender
  - readUnsignedByteOrThrow
```
public int readUnsignedByteOrThrow()
                            throws BufferUnderflowException
```
    Specified by:
    
    readUnsignedByteOrThrow in interface ByteStringParser
    
    Returns:
    
    the next unsigned byte or -1 if selfTerminating and the end is reached.
    
    Throws:
    
    BufferUnderflowException - if the end is reached and selfTerminating is false.
  - zeroOut
```
public Bytes zeroOut(long start,
                     long end)
```
    Description copied from interface: RandomDataOutput
    
    fill the Bytes with zeros.
    
    Specified by:
    
    zeroOut in interface RandomDataOutput
    
    Parameters:
    
    start - first byte to zero out
    
    end - the first byte after the last to zero out (exclusive bound)
    
    Returns:
    
    this
  - zeroOut
```
public Bytes zeroOut(long start,
                     long end,
                     boolean ifNotZero)
```
    Description copied from interface: RandomDataOutput
    
    fill the Bytes with zeros, and clear the position, avoiding touching pages unnecessarily
    
    Specified by:
    
    zeroOut in interface RandomDataOutput
    
    Parameters:
    
    start - first byte to zero out
    
    end - the first byte after the last to zero out (exclusive bound)
    
    ifNotZero - only set to zero after checking the value is not zero.
    
    Returns:
    
    this
  - writeShort
```
public void writeShort(int v)
```
    Description copied from interface: RandomDataOutput
    Writes two bytes to the output stream to represent the value of the argument. The byte values to be written, in the order shown for big endian machines and the opposite for little endian, are:
```
 (byte)(0xff & (v >> 8))
 (byte)(0xff & v)
  
```
    The bytes written by this method may be read by the readShort method of interface DataInput , which will then return a short equal to (short)v.
    Specified by:
    
    writeShort in interface DataOutput
    
    Specified by:
    
    writeShort in interface RandomDataOutput
    
    Parameters:
    
    v - the short value to be written.
  - addShort
```
public short addShort(long offset,
                      short s)
```
    Specified by:
    
    addShort in interface RandomDataUpdate
  - writeUnsignedInt
```
public void writeUnsignedInt(long v)
```
    Description copied from interface: RandomDataOutput
    Writes an int value, which is comprised of four bytes, to the output stream. The byte values to be written, in the order shown for big endian machines and the opposite for little endian, are:
```
 (byte)(0xff & (v >> 24))
 (byte)(0xff & (v >> 16))
 (byte)(0xff & (v >>    8))
 (byte)(0xff & v)
 
```
    The bytes written by this method may be read by the readUnsignedInt method of interface RandomDataInput , which will then return an long equal to v & 0xFFFFFFFF.
    Specified by:
    
    writeUnsignedInt in interface RandomDataOutput
    
    Parameters:
    
    v - the int value to be written.
  - free
```
public void free()
```
    Specified by:
    
    free in interface BytesStore
  - readUnsignedShort
```
public int readUnsignedShort()
```
    Description copied from interface: RandomDataInput
    Reads two input bytes and returns an int value in the range 0 through 65535. Let a be the first byte read and b be the second byte on big endian machines, and the opposite on little endian machines. The value returned is:
```
     (((a & 0xff) << 8) | (b & 0xff))
 
```
    This method is suitable for reading the bytes written by the writeUnsignedShort method of interface DataOutput if the argument to writeUnsignedShort was intended to be a value in the range 0 through 65535.
    Specified by:
    
    readUnsignedShort in interface DataInput
    
    Specified by:
    
    readUnsignedShort in interface RandomDataInput
    
    Returns:
    
    the unsigned 16-bit value read.
  - writeStopBit
```
public void writeStopBit(long n)
```
    Description copied from interface: RandomDataOutput
    
    Stop bit encoding numbers. This will write the same number of bytes whether you used a byte, short or int.
    
    Specified by:
    
    writeStopBit in interface RandomDataOutput
    
    Parameters:
    
    n - the number to write
  - readObject
```
@Nullable
public <T> T readObject(Class<T> tClass)
                           throws IllegalStateException
```
    Description copied from interface: RandomDataInput
    
    Read and return an object. The class that implements this interface defines where the object is "read" from.
    
    Specified by:
    
    readObject in interface RandomDataInput
    
    Type Parameters:
    
    T - the class of the object to read
    
    Parameters:
    
    tClass - the class of the object to read
    
    Returns:
    
    the object read from the stream
    
    Throws:
    
    IllegalStateException - the class of a serialized object cannot be found or any of the usual Input/Output related exceptions occur.
  - writeCompactInt
```
public void writeCompactInt(int v)
```
    Description copied from interface: RandomDataOutput
    
    Writes two or six bytes as follows; Integer.MIN_VALUE => Short.MIN_VALUE, Integer.MAX_VALUE => Short.MAX_VALUE, Short.MIN_VALUE+2 to Short.MAX_VALUE-1 => writeShort(x), default => writeShort(Short.MIN_VALUE+1; writeInt(x)
    The bytes written by this method may be read by the readCompactInt method of interface RandomDataInput , which will then return a int equal to v.
    
    Specified by:
    
    writeCompactInt in interface RandomDataOutput
    
    Parameters:
    
    v - the int value to be written.
  - writeOrderedLong
```
public void writeOrderedLong(long v)
```
    Description copied from interface: RandomDataOutput
    
    Same as writeLong but include an ordered write barrier. This means all writes will be visible on a read barrier if this write is visible. This might not be visible to be same thread for some clock cycles so an immediate read could see an old value
    This is much faster than a volatile write which stalls the pipeline. The data is visible to other threads at the same time.
    
    Specified by:
    
    writeOrderedLong in interface RandomDataOutput
    
    Parameters:
    
    v - value to write
  - addByte
```
public byte addByte(long offset,
                    byte b)
```
    Specified by:
    
    addByte in interface RandomDataUpdate
  - readVolatileInt
```
public int readVolatileInt()
```
    Description copied from interface: RandomDataInput
    This is the same as readInt() except a read barrier is performed first.
    Reads four input bytes and returns an int value. Let a-d be the first through fourth bytes read on big endian machines, and the opposite on little endian machines. The value returned is:
```
 
 (((a & 0xff) << 24) | ((b & 0xff) << 16) | ((c & 0xff) << 8) | (d & 0xff))
 
```
    This method is suitable for reading bytes written by the writeOrderedInt or writeVolatileInt method of interface RandomDataOutput.
    Specified by:
    
    readVolatileInt in interface RandomDataInput
    
    Returns:
    
    the int value read.
  - close
```
public void close()
```
    Description copied from interface: RandomDataInput
    
    Finishes the excerpt entry if not finished()
    
    Specified by:
    
    close in interface ObjectInput
    
    Specified by:
    
    close in interface ObjectOutput
    
    Specified by:
    
    close in interface AutoCloseable
    
    Specified by:
    
    close in interface RandomDataInput
    
    Specified by:
    
    close in interface RandomDataOutput
  - read
```
public void read(@NotNull
                 ByteBuffer bb)
```
    Description copied from interface: RandomDataInput
    
    Copy bytes into a ByteBuffer to the minimum of the length remaining() in the ByteBuffer or the Excerpt.
    
    Specified by:
    
    read in interface RandomDataInput
    
    Parameters:
    
    bb - to copy into
  - read
```
public void read(@NotNull
                 ByteBuffer bb,
                 int length)
```
    Description copied from interface: RandomDataInput
    
    Copy bytes into a ByteBuffer to the minimum of the length in the ByteBuffer or the Excerpt.
    
    Specified by:
    
    read in interface RandomDataInput
    
    Parameters:
    
    bb - to copy into
    
    length - number of bytes to copy
  - append
```
@NotNull
public ByteStringAppender append(long l,
                                          int base)
```
    Specified by:
    
    append in interface ByteStringAppender
  - skip
```
public long skip(long n)
```
    Description copied from interface: RandomDataInput
    
    Skips n bytes of input.
    
    Specified by:
    
    skip in interface ObjectInput
    
    Specified by:
    
    skip in interface RandomDataInput
    
    Parameters:
    
    n - the number of bytes to be skipped
    
    Returns:
    
    the actual number of bytes skipped.
  - selfTerminating
```
public boolean selfTerminating()
```
    Specified by:
    
    selfTerminating in interface ByteStringParser
    
    Returns:
    
    if this Bytes self terminates.
  - writeBytes
```
public void writeBytes(@NotNull
                       String s)
```
    Description copied from interface: RandomDataOutput
    
    Writes a string to the output stream. For every character in the string s, taken in order, one byte is written to the output stream. If s is null, a NullPointerException is thrown.
    If s.length is zero, then no bytes are written. Otherwise, the character s[0] is written first, then s[1], and so on; the last character written is s[s.length-1]. For each character, one byte is written, the low-order byte, in exactly the manner of the writeByte method . The high-order eight bits of each character in the string are ignored.
    
    Specified by:
    
    writeBytes in interface DataOutput
    
    Specified by:
    
    writeBytes in interface RandomDataOutput
    
    Parameters:
    
    s - the string of bytes to be written. Cannot be null.
  - size
```
public long size()
```
    Specified by:
    
    size in interface BytesStore
  - readCompactUnsignedShort
```
public int readCompactUnsignedShort()
```
    Description copied from interface: RandomDataInput
    
    Reads one or three input bytes and returns a short value. Let a be the first byte read. This mapped as follows; -1 => readUnsignedShort(), default => (a & 0xFF)
    This method is suitable for reading the bytes written by the writeCompactUnsignedShort method of interface RandomDataOutput.
    
    Specified by:
    
    readCompactUnsignedShort in interface RandomDataInput
    
    Returns:
    
    the unsigned 16-bit value read.
  - append
```
@NotNull
public ByteStringAppender append(@NotNull
                                          CharSequence s,
                                          int start,
                                          int end)
```
    Specified by:
    
    append in interface Appendable
    
    Specified by:
    
    append in interface ByteStringAppender
  - writeCompactLong
```
public void writeCompactLong(long v)
```
    Description copied from interface: RandomDataOutput
    
    Writes four or twelve bytes as follows Long.MIN_VALUE => Integer.MIN_VALUE, Long.MAX_VALUE => Integer.MAX_VALUE, Integer.MIN_VALUE+2 to Integer.MAX_VALUE-1 => writeInt(x), default => writeInt(Integer.MIN_VALUE+1; writeLong(x)
    The bytes written by this method may be read by the readCompactLong method of interface RandomDataInput , which will then return a long equal to v.
    
    Specified by:
    
    writeCompactLong in interface RandomDataOutput
    
    Parameters:
    
    v - the long value to be written.
  - readCompactDouble
```
public double readCompactDouble()
```
    Description copied from interface: RandomDataInput
    
    Reads the first four bytes as readFloat(). If this is Float.NaN, the next eight bytes are read as readDouble()
    
    Specified by:
    
    readCompactDouble in interface RandomDataInput
    
    Returns:
    
    the double value read.
  - writeOrderedInt
```
public void writeOrderedInt(long offset,
                            int v)
```
    Description copied from interface: RandomDataOutput
    
    Same as writeInt but include an ordered write barrier. This means all writes will be visible on a read barrier if this write is visible. This might not be visible to be same thread for some clock cycles so an immediate read could see an old value
    This is much faster than writeVolatileInt as the volatile write stalls the pipeline. The data is visible to other threads at the same time.
    
    Specified by:
    
    writeOrderedInt in interface RandomDataOutput
    
    Parameters:
    
    offset - to write to
    
    v - value to write
  - writeObject
```
public void writeObject(Object object,
                        int start,
                        int end)
```
    Description copied from interface: RandomDataOutput
    
    Copy data from an Object from bytes start to end.
    
    Specified by:
    
    writeObject in interface RandomDataOutput
    
    Parameters:
    
    object - to copy from
    
    start - first byte inclusive
    
    end - last byte exclusive.
  - asString
```
public CharSequence asString()
```
    Description copied from interface: ByteStringParser
    
    Dump the contents of Bytes as a CharSequence
    
    Specified by:
    
    asString in interface ByteStringParser
    
    Returns:
    
    the CharSequence for these Bytes.
  - readUTFΔ
```
@Nullable
public String readUTFΔ()
```
    Description copied from interface: RandomDataInput
    
    The same as readUTF() except the length is stop bit encoded. This saves one byte for strings shorter than 128 chars. null values are also supported
    
    Specified by:
    
    readUTFΔ in interface RandomDataInput
    
    Returns:
    
    a Unicode string or null if writeUTFΔ(null) was called
  - flip
```
public Bytes flip()
```
    Description copied from interface: BytesCommon
    Flips this buffer. The limit is set to the current position and then the position is set to zero. If the mark is defined then it is discarded.
    After a sequence of channel-read or put operations, invoke this method to prepare for a sequence of channel-write or relative get operations. For example:
```
 buf.put(magic);    // Prepend header
 in.read(buf);      // Read data into rest of buffer
 buf.flip();        // Flip buffer
 out.write(buf);    // Write header + data to channel
 
```
    This method is often used in conjunction with the compact method when transferring data from one place to another.
    Specified by:
    
    flip in interface BytesCommon
    
    Returns:
    
    This buffer
  - addInt
```
public int addInt(long offset,
                  int i)
```
    Specified by:
    
    addInt in interface RandomDataUpdate
  - readUnsignedInt
```
public long readUnsignedInt(long offset)
```
    Description copied from interface: RandomDataInput
    Reads four input bytes and returns an int value. Let a-d be the first through fourth bytes read on big endian machines, and the opposite on little endian machines. The value returned is:
```
 
 ((((long) a & 0xff) << 24) | ((b & 0xff) << 16) | ((c & 0xff) << 8) | (d &
 0xff))
 
```
    This method is suitable for reading bytes written by the writeUnsignedInt method of interface RandomDataOutput.
    Specified by:
    
    readUnsignedInt in interface RandomDataInput
    
    Parameters:
    
    offset - to read from
    
    Returns:
    
    the unsigned int value read.
  - writeByte
```
public void writeByte(int v)
```
    Description copied from interface: RandomDataOutput
    
    Writes to the output stream the eight low- order bits of the argument v. The 24 high-order bits of v are ignored. (This means that writeByte does exactly the same thing as write for an integer argument.) The byte written by this method may be read by the readByte method of interface DataInput, which will then return a byte equal to (byte)v.
    
    Specified by:
    
    writeByte in interface DataOutput
    
    Specified by:
    
    writeByte in interface RandomDataOutput
    
    Parameters:
    
    v - the byte value to be written.
  - writeUnsignedInt
```
public void writeUnsignedInt(long offset,
                             long v)
```
    Description copied from interface: RandomDataOutput
    Writes an int value, which is comprised of four bytes, to the output stream. The byte values to be written, in the order shown for big endian machines and the opposite for little endian, are:
```
 (byte)(0xff & (v >> 24))
 (byte)(0xff & (v >> 16))
 (byte)(0xff & (v >>    8))
 (byte)(0xff & v)
 
```
    The bytes written by this method may be read by the readUnsignedInt method of interface RandomDataInput , which will then return an long equal to v & 0xFFFFFFFF.
    Specified by:
    
    writeUnsignedInt in interface RandomDataOutput
    
    Parameters:
    
    offset - to be written to
    
    v - the int value to be written.
  - writeInt
```
public void writeInt(int v)
```
    Description copied from interface: RandomDataOutput
    Writes an int value, which is comprised of four bytes, to the output stream. The byte values to be written, in the order shown for big endian machines and the opposite for little endian, are:
```
 (byte)(0xff & (v >> 24))
 (byte)(0xff & (v >> 16))
 (byte)(0xff & (v >>    8))
 (byte)(0xff & v)
 
```
    The bytes written by this method may be read by the readInt method of interface DataInput , which will then return an int equal to v.
    Specified by:
    
    writeInt in interface DataOutput
    
    Specified by:
    
    writeInt in interface RandomDataOutput
    
    Parameters:
    
    v - the int value to be written.
  - readShort
```
public short readShort()
```
    Description copied from interface: RandomDataInput
    Reads two input bytes and returns a short value. Let a be the first byte read and b be the second byte on big endian machines, and the opposite on little endian machines. The value returned is:
```
(short)((a << 8) | (b & 0xff))
 
```
    This method is suitable for reading the bytes written by the writeShort method of interface DataOutput.
    Specified by:
    
    readShort in interface DataInput
    
    Specified by:
    
    readShort in interface RandomDataInput
    
    Returns:
    
    the 16-bit value read.
  - writeUnsignedByte
```
public void writeUnsignedByte(long offset,
                              int v)
```
    Description copied from interface: RandomDataOutput
    
    Writes to the output stream the eight low- order bits of the argument v. The 24 high-order bits of v are ignored. (This means that writeByte does exactly the same thing as write for an integer argument.) The byte written by this method may be read by the readUnsignedByte method of interface DataInput, which will then return a byte equal to v & 0xFF.
    
    Specified by:
    
    writeUnsignedByte in interface RandomDataOutput
    
    Parameters:
    
    offset - to write byte
    
    v - the unsigned byte value to be written.
  - asString
```
public void asString(Appendable appendable)
```
    Description copied from interface: ByteStringParser
    
    Dump the contents of this Bytes as text in the Appendable.
    
    Specified by:
    
    asString in interface ByteStringParser
    
    Parameters:
    
    appendable - to append to
  - readInt48
```
public long readInt48(long offset)
```
    Description copied from interface: RandomDataInput
    Reads six input bytes and returns a long value. Let a-f be the first through sixth bytes read on big endian machines, and the opposite on little endian machines. The value returned is:
```
 
 (((long)(a & 0xff) << 56) |
  ((long)(b & 0xff) << 48) |
  ((long)(c & 0xff) << 40) |
  ((long)(d & 0xff) << 32) |
  ((long)(e & 0xff) << 24) |
  ((long)(f & 0xff) << 16)) >> 16
 
```
    This method is suitable for reading bytes written by the writeInt48 method of interface RandomDataOutput.
    Specified by:
    
    readInt48 in interface RandomDataInput
    
    Parameters:
    
    offset - of the long to read
    
    Returns:
    
    the long value read.
  - unlockRWReadLock
```
public void unlockRWReadLock(long offset)
                      throws IllegalStateException
```
    Description copied from interface: RandomDataUpdate
    
    Uses the 64-bit long at the offset as a non-reentrant read/write lock. There can be up to 2^20-1 threads reading, or waiting to read on a lock.
    
    Specified by:
    
    unlockRWReadLock in interface RandomDataUpdate
    
    Parameters:
    
    offset - of the long monitor
    
    Throws:
    
    IllegalStateException - if the monitor is in an illegal state
  - readUTF
```
@NotNull
public String readUTF()
```
    Description copied from interface: RandomDataInput
    Reads in a string that has been encoded using a modified UTF-8 format. The general contract of readUTF is that it reads a representation of a Unicode character string encoded in modified UTF-8 format; this string of characters is then returned as a String.
    First, two bytes are read and used to construct an unsigned 16-bit integer in exactly the manner of the readUnsignedShort method . This integer value is called the UTF length and specifies the number of additional bytes to be read. These bytes are then converted to characters by considering them in groups. The length of each group is computed from the value of the first byte of the group. The byte following a group, if any, is the first byte of the next group.
    If the first byte of a group matches the bit pattern 0xxxxxxx (where x means "may be 0 or 1"), then the group consists of just that byte. The byte is zero-extended to form a character.
    If the first byte of a group matches the bit pattern 110xxxxx, then the group consists of that byte a and a second byte b. If there is no byte b (because byte a was the last of the bytes to be read), or if byte b does not match the bit pattern 10xxxxxx, then a UTFDataFormatException is thrown. Otherwise, the group is converted to the character:
```
(char)(((a& 0x1F) << 6) | (b & 0x3F))
 
```
    If the first byte of a group matches the bit pattern 1110xxxx, then the group consists of that byte a and two more bytes b and c. If there is no byte c (because byte a was one of the last two of the bytes to be read), or either byte b or byte c does not match the bit pattern 10xxxxxx, then a UTFDataFormatException is thrown. Otherwise, the group is converted to the character:
```
 (char)(((a & 0x0F) << 12) | ((b & 0x3F) << 6) | (c & 0x3F))
 
```
    If the first byte of a group matches the pattern 1111xxxx or the pattern 10xxxxxx, then a UTFDataFormatException is thrown.
    If end of file is encountered at any time during this entire process, then an EOFException is thrown.
    After every group has been converted to a character by this process, the characters are gathered, in the same order in which their corresponding groups were read from the input stream, to form a String, which is returned.
    The writeUTF method of interface DataOutput may be used to write data that is suitable for reading by this method.
    Specified by:
    
    readUTF in interface DataInput
    
    Specified by:
    
    readUTF in interface RandomDataInput
    
    Returns:
    
    a Unicode string.
  - writeUnsignedShort
```
public void writeUnsignedShort(long offset,
                               int v)
```
    Description copied from interface: RandomDataOutput
    Writes two bytes to the output stream to represent the value of the argument. The byte values to be written, in the order shown for big endian machines and the opposite for little endian, are:
```
 (byte)(0xff & (v >> 8))
 (byte)(0xff & v)
  
```
    The bytes written by this method may be read by the readShort method of interface RandomDataInput , which will then return a short equal to (short)v.
    Specified by:
    
    writeUnsignedShort in interface RandomDataOutput
    
    Parameters:
    
    offset - to be written to
    
    v - the unsigned short value to be written.
  - readFully
```
public void readFully(@NotNull
                      char[] data)
```
    Specified by:
    
    readFully in interface RandomDataInput
  - writeInt24
```
public void writeInt24(long offset,
                       int v)
```
    Description copied from interface: RandomDataOutput
    Writes an int value, which is comprised of three bytes, to the output stream. The byte values to be written, in the order shown for big endian machines and the opposite for little endian, are:
```
 (byte)(0xff & (v >> 16))
 (byte)(0xff & (v >>    8))
 (byte)(0xff & v)
 
```
    The bytes written by this method may be read by the readInt24 method of interface RandomDataInput , which will then return an int equal to v.
    Specified by:
    
    writeInt24 in interface RandomDataOutput
    
    Parameters:
    
    offset - to be written to
    
    v - the int value to be written.
  - writeChars
```
public void writeChars(@NotNull
                       CharSequence cs)
```
    Description copied from interface: RandomDataOutput
    
    Writes chars of the given CharSequence to the bytes, without encoding.
    
    Specified by:
    
    writeChars in interface RandomDataOutput
    
    Parameters:
    
    cs - the CharSequence to be written. Cannot be null.
    
    See Also:
    
    RandomDataOutput.writeChars(String)
  - readFloat
```
public float readFloat(long offset)
```
    Description copied from interface: RandomDataInput
    
    Reads four input bytes and returns a float value. It does this by first constructing an int value in exactly the manner of the readInt method, then converting this int value to a float in exactly the manner of the method Float.intBitsToFloat. This method is suitable for reading bytes written by the writeFloat method of interface DataOutput.
    
    Specified by:
    
    readFloat in interface RandomDataInput
    
    Parameters:
    
    offset - to read from
    
    Returns:
    
    the float value read.
  - capacity
```
public long capacity()
```
    Specified by:
    
    capacity in interface BytesCommon
    
    Returns:
    
    space available
  - subSequence
```
public CharSequence subSequence(int start,
                                int end)
```
    Specified by:
    
    subSequence in interface CharSequence
  - clear
```
public Bytes clear()
```
    Description copied from interface: BytesCommon
    Clears this buffer. The position is set to zero, the limit is set to the capacity, and the mark is discarded.
    Invoke this method before using a sequence of channel-read or put operations to fill this buffer. For example:
```
 buf.clear();     // Prepare buffer for reading
 in.read(buf);    // Read data
 
```
    This method does not actually erase the data in the buffer, but it is named as if it did because it will most often be used in situations in which that might as well be the case.
    Specified by:
    
    clear in interface BytesCommon
    
    Returns:
    
    This buffer
  - readUTFΔ
```
@Nullable
public String readUTFΔ(long offset)
                          throws IllegalStateException
```
    Description copied from interface: RandomDataInput
    
    The same as readUTFΔ() except an offset is given.
    
    Specified by:
    
    readUTFΔ in interface RandomDataInput
    
    Parameters:
    
    offset - to read from
    
    Returns:
    
    a Unicode string or null if writeUTFΔ(null) was called
    
    Throws:
    
    IllegalStateException - if the length to be read is out of range.
  - objectSerializer
```
@NotNull
public ObjectSerializer objectSerializer()
```
    Specified by:
    
    objectSerializer in interface BytesCommon
    
    Specified by:
    
    objectSerializer in interface BytesStore
    
    Returns:
    
    the factory for marshallers.
  - writeOrderedLong
```
public void writeOrderedLong(long offset,
                             long v)
```
    Description copied from interface: RandomDataOutput
    
    Same as writeLong but include an ordered write barrier. This means all writes will be visible on a read barrier if this write is visible. This might not be visible to be same thread for some clock cycles so an immediate read could see an old value
    This is much faster than a volatile write which stalls the pipeline. The data is visible to other threads at the same time.
    
    Specified by:
    
    writeOrderedLong in interface RandomDataOutput
    
    Parameters:
    
    offset - to be written to
    
    v - value to write
  - addAtomicLong
```
public long addAtomicLong(long offset,
                          long l)
```
    Specified by:
    
    addAtomicLong in interface RandomDataUpdate
  - append
```
@NotNull
public ByteStringAppender append(char c)
```
    Specified by:
    
    append in interface Appendable
    
    Specified by:
    
    append in interface ByteStringAppender
  - busyLockInt
```
public void busyLockInt(long offset)
                 throws InterruptedException,
                        IllegalStateException
```
    Description copied from interface: RandomDataUpdate
    
    Lock which uses 4 bytes. It store the lower 24 bits of the Thread Id and the re-entrant count as 8 bit. This means if you create more than 16 million threads you can get a collision, and if you try to re-enter 255 times you will get an ISE
    
    Specified by:
    
    busyLockInt in interface RandomDataUpdate
    
    Parameters:
    
    offset - of the start of the 4-byte lock
    
    Throws:
    
    InterruptedException - if interrupted
    
    IllegalStateException - if the thread tries to lock it 255 nested time (without an unlock)
  - resetLockInt
```
public void resetLockInt(long offset)
```
    Description copied from interface: RandomDataUpdate
    
    Lock which uses 4 bytes. Reset forces the lock to be cleared. Use this only when the program believes the locked thread is dead.
    
    Specified by:
    
    resetLockInt in interface RandomDataUpdate
    
    Parameters:
    
    offset - of the start of the 4-byte lock
  - readLine
```
@Nullable
public String readLine()
```
    Description copied from interface: RandomDataInput
    
    Reads the next line of text from the input stream. It reads successive bytes, converting each byte separately into a character, until it encounters a line terminator or end of file; the characters read are then returned as a String. Note that because this method processes bytes, it does not support input of the full Unicode character set.
    If end of file is encountered before even one byte can be read, then null is returned. Otherwise, each byte that is read is converted to type char by zero-extension. If the character '\n' is encountered, it is discarded and reading ceases. If the character '\r' is encountered, it is discarded and, if the following byte converts to the character '\n', then that is discarded also; reading then ceases. If end of file is encountered before either of the characters '\n' and '\r' is encountered, reading ceases. Once reading has ceased, a String is returned that contains all the characters read and not discarded, taken in order. Note that every character in this string will have a value less than \u0100, that is, (char)256.
    
    Specified by:
    
    readLine in interface DataInput
    
    Specified by:
    
    readLine in interface RandomDataInput
    
    Returns:
    
    the next line of text from the input stream, or null if the end of file is encountered before a byte can be read.
  - readChar
```
public char readChar(long offset)
```
    Description copied from interface: RandomDataInput
    Reads two input bytes and returns a char value. Let a be the first byte read and b be the second byte on big endian machines, and the opposite on little endian machines. The value returned is:
```
(char)((a << 8) | (b & 0xff))
 
```
    This method is suitable for reading bytes written by the writeChar method of interface RandomDataOutput.
    Specified by:
    
    readChar in interface RandomDataInput
    
    Parameters:
    
    offset - of the char to read.
    
    Returns:
    
    the char value read.
  - readInstance
```
@Nullable
public <T> T readInstance(@NotNull
                                    Class<T> objClass,
                                    T obj)
```
    Description copied from interface: RandomDataInput
    
    Read an instance of a class assuming objClass was provided when written.
    
    Specified by:
    
    readInstance in interface RandomDataInput
    
    Type Parameters:
    
    T - the class of the object to read
    
    Parameters:
    
    objClass - class to write
    
    obj - to reuse or null if a new object is needed
    
    Returns:
    
    the object read from the stream
  - append
```
@NotNull
public ByteStringAppender append(boolean b)
```
    Description copied from interface: ByteStringAppender
    
    Writes "true" or "false".
    
    Specified by:
    
    append in interface ByteStringAppender
    
    Parameters:
    
    b - to write.
    
    Returns:
    
    this.
  - addUnsignedByte
```
public int addUnsignedByte(long offset,
                           int i)
```
    Specified by:
    
    addUnsignedByte in interface RandomDataUpdate
  - readFully
```
public void readFully(@NotNull
                      byte[] byteArray,
                      int off,
                      int len)
```
    Description copied from interface: RandomDataInput
    Reads len bytes from an input stream.
    This method blocks until one of the following conditions occurs:
    - len bytes of input data are available, in which case a normal return is made.
    - End of file is detected, in which case an EOFException is thrown.
    - An I/O error occurs, in which case an IOException other than EOFException is thrown.
    If bytes is null, a NullPointerException is thrown. If off is negative, or len is negative, or off+len is greater than the length of the array bytes, then an IndexOutOfBoundsException is thrown. If len is zero, then no bytes are read. Otherwise, the first byte read is stored into element bytes[off], the next one into bytes[off+1], and so on. The number of bytes read is, at most, equal to len.
    Specified by:
    
    readFully in interface DataInput
    
    Specified by:
    
    readFully in interface RandomDataInput
    
    Parameters:
    
    byteArray - the buffer into which the data is read.
    
    off - an int specifying the offset into the data.
    
    len - an int specifying the number of bytes to read.
  - readFully
```
public void readFully(@NotNull
                      char[] data,
                      int off,
                      int len)
```
    Specified by:
    
    readFully in interface RandomDataInput
  - addAndGetInt
```
public int addAndGetInt(long offset,
                        int delta)
```
    Description copied from interface: RandomDataOutput
    
    Atomically adds the given value to the current value.
    
    Specified by:
    
    addAndGetInt in interface RandomDataOutput
    
    Parameters:
    
    offset - of the int value to use.
    
    delta - the value to add
    
    Returns:
    
    the updated value
  - addUnsignedInt
```
public long addUnsignedInt(long offset,
                           long i)
```
    Specified by:
    
    addUnsignedInt in interface RandomDataUpdate
  - writeInt48
```
public void writeInt48(long v)
```
    Description copied from interface: RandomDataOutput
    Writes a long value, which is comprised of eight bytes, to the output stream. The byte values to be written, in the order shown for big endian machines and the opposite for little endian, are:
```
 (byte)(0xff & (v >> 40))
 (byte)(0xff & (v >> 32))
 (byte)(0xff & (v >> 24))
 (byte)(0xff & (v >> 16))
 (byte)(0xff & (v >>  8))
 (byte)(0xff & v)
 
```
    The bytes written by this method may be read by the readInt48 method of interface RandomDataInput , which will then return a long equal to v & ((1L << 48) - 1).
    Specified by:
    
    writeInt48 in interface RandomDataOutput
    
    Parameters:
    
    v - the long value to be written.
  - append
```
@NotNull
public ByteStringAppender append(@NotNull
                                          MutableDecimal md)
```
    Specified by:
    
    append in interface ByteStringAppender
  - readMap
```
public <K,V> Map<K,V> readMap(@NotNull
                              Map<K,V> map,
                              @NotNull
                              Class<K> kClass,
                              @NotNull
                              Class<V> vClass)
```
    Description copied from interface: RandomDataInput
    
    Read a stop bit encoded length and populates this Map after zeroOut()ing it.
    This is suitable to reading a list written using writeMap() in the RandomDataOutput interface
    
    Specified by:
    
    readMap in interface RandomDataInput
    
    Type Parameters:
    
    K - the map key class
    
    V - the map value class
    
    Parameters:
    
    map - to populate
    
    kClass - the map key class
    
    vClass - the map value class
    
    Returns:
    
    the map
  - charAt
```
public char charAt(int index)
```
    Specified by:
    
    charAt in interface CharSequence
  - writeOrderedFloat
```
public void writeOrderedFloat(long offset,
                              float v)
```
    Description copied from interface: RandomDataOutput
    
    Same as writeFloat but include an ordered write barrier. This means all writes will be visible on a read barrier if this write is visible. This might not be visible to be same thread for some clock cycles so an immediate read could see an old value
    This is much faster than a volatile write which stalls the pipeline. The data is visible to other threads at the same time.
    
    Specified by:
    
    writeOrderedFloat in interface RandomDataOutput
    
    Parameters:
    
    offset - to write to
    
    v - value to write
  - unlockRWWriteLock
```
public void unlockRWWriteLock(long offset)
                       throws IllegalStateException
```
    Description copied from interface: RandomDataUpdate
    
    Uses the 64-bit long at the offset as a non-reentrant read/write lock. There can be up to 2^20-1 threads reading, or waiting to read on a lock.
    
    Specified by:
    
    unlockRWWriteLock in interface RandomDataUpdate
    
    Parameters:
    
    offset - of the long monitor
    
    Throws:
    
    IllegalStateException - if the monitor is in an illegal state
  - parseUtf8
```
public void parseUtf8(@NotNull
                      StringBuilder builder,
                      @NotNull
                      StopCharTester tester)
               throws BufferUnderflowException
```
    Description copied from interface: ByteStringParser
    
    Populate a StringBuilder with the UTF encoded text until the end.
    
    Specified by:
    
    parseUtf8 in interface ByteStringParser
    
    Parameters:
    
    builder - to zeroOut and append to.
    
    tester - to detect when to stop.
    
    Throws:
    
    BufferUnderflowException
  - inputStream
```
@NotNull
public InputStream inputStream()
```
    Specified by:
    
    inputStream in interface BytesCommon
    
    Returns:
    
    these Bytes as an InputStream
  - remaining
```
public long remaining()
```
    Specified by:
    
    remaining in interface BytesCommon
    
    Returns:
    
    space remaining in bytes
  - writeByte
```
public void writeByte(long offset,
                      int b)
```
    Description copied from interface: RandomDataOutput
    
    Writes to the output stream the eight low-order bits of the argument b. The 24 high-order bits of b are ignored.
    
    Specified by:
    
    writeByte in interface RandomDataOutput
    
    Parameters:
    
    offset - to write byte
    
    b - the byte to be written.
  - readDouble
```
public double readDouble()
```
    Description copied from interface: RandomDataInput
    
    Reads eight input bytes and returns a double value. It does this by first constructing a long value in exactly the manner of the readLong method, then converting this long value to a double in exactly the manner of the method Double.longBitsToDouble. This method is suitable for reading bytes written by the writeDouble method of interface DataOutput.
    
    Specified by:
    
    readDouble in interface DataInput
    
    Specified by:
    
    readDouble in interface RandomDataInput
    
    Returns:
    
    the double value read.
  - readCompactInt
```
public int readCompactInt()
```
    Description copied from interface: RandomDataInput
    
    Reads two or six input bytes and returns an int value. Let a be the first short read with readShort(). This mapped as follows; Short.MIN_VALUE => Integer.MIN_VALUE, Short.MAX_VALUE => Integer.MAX_VALUE, Short.MIN_VALUE+2 to Short.MAX_VALUE-1 => same as short value, Short.MIN_VALUE+1 => readInt().
    This method is suitable for reading the bytes written by the writeCompactInt method of interface RandomDataOutput.
    
    Specified by:
    
    readCompactInt in interface RandomDataInput
    
    Returns:
    
    the 32-bit value read.
  - release
```
public boolean release()
```
    Specified by:
    
    release in interface ReferenceCounted
  - readBoolean
```
public boolean readBoolean(long offset)
```
    Description copied from interface: RandomDataInput
    
    Reads one input byte and returns true if that byte is nonzero, false if that byte is zero. This method is suitable for reading the byte written by the writeBoolean method of interface RandomDataOutput.
    
    Specified by:
    
    readBoolean in interface RandomDataInput
    
    Parameters:
    
    offset - to read byte translated into a boolean
    
    Returns:
    
    the boolean value read.
  - writeBoolean
```
public void writeBoolean(boolean v)
```
    Description copied from interface: RandomDataOutput
    
    Writes a boolean value to this output stream. If the argument v is true, the value (byte)1 is written; if v is false, the value (byte)0 is written. The byte written by this method may be read by the readBoolean method of interface DataInput, which will then return a boolean equal to v.
    
    Specified by:
    
    writeBoolean in interface DataOutput
    
    Specified by:
    
    writeBoolean in interface RandomDataOutput
    
    Parameters:
    
    v - the boolean to be written.
  - read
```
public int read(@NotNull
                byte[] byteArray)
```
    Description copied from interface: RandomDataInput
    
    Reads into an array of bytes. This method will block until some input is available.
    
    Specified by:
    
    read in interface ObjectInput
    
    Specified by:
    
    read in interface RandomDataInput
    
    Parameters:
    
    byteArray - the buffer into which the data is read
    
    Returns:
    
    the actual number of bytes read, -1 is returned when the end of the stream is reached.
  - writeChars
```
public void writeChars(@NotNull
                       String s)
```
    Description copied from interface: RandomDataOutput
    
    Writes every character in the string s, to the output stream, in order, two bytes per character. If s is null, a NullPointerException is thrown. If s.length is zero, then no characters are written. Otherwise, the character s[0] is written first, then s[1], and so on; the last character written is s[s.length-1]. For each character, two bytes are actually written, high-order byte first, in exactly the manner of the writeChar method.
    
    Specified by:
    
    writeChars in interface DataOutput
    
    Specified by:
    
    writeChars in interface RandomDataOutput
    
    Parameters:
    
    s - the string value to be written. Cannot be null.
    
    See Also:
    
    RandomDataOutput.writeChars(CharSequence)
  - slice
```
public Bytes slice()
```
    Description copied from interface: BytesCommon
    
    Creates a new bytes whose content is a shared subsequence of this bytes' content.
    The content of the new bytes will start at this bytes' current position. Changes to this bytes' content will be visible in the new bytes, and vice versa; the two bytes' position and limit values will be independent.
    The new bytes' position will be zero, its capacity and its limit will be the number of bytes remaining in this bytes.
    slice() is equivalent of slice(0, remaining()).
    
    Specified by:
    
    slice in interface BytesCommon
    
    Returns:
    
    the new bytes
    
    See Also:
    
    BytesCommon.slice(long, long)
  - zeroOut
```
public Bytes zeroOut()
```
    Description copied from interface: RandomDataOutput
    
    fill the Bytes with zeros, and clear the position.
    
    Specified by:
    
    zeroOut in interface RandomDataOutput
    
    Returns:
    
    this
  - toString
```
public void toString(Appendable sb,
                     long start,
                     long position,
                     long end)
```
    Description copied from interface: BytesCommon
    
    Write a portion of the Bytes to an Appendable for printing.
    
    Specified by:
    
    toString in interface BytesCommon
    
    Parameters:
    
    sb - to append to
    
    start - first byte
    
    position - where to place a cursor or 0 = none.
    
    end - last byte to append.
  - writeOrderedDouble
```
public void writeOrderedDouble(long offset,
                               double v)
```
    Description copied from interface: RandomDataOutput
    
    Same as writeDouble but include an ordered write barrier. This means all writes will be visible on a read barrier if this write is visible. This might not be visible to be same thread for some clock cycles so an immediate read could see an old value
    This is much faster than a volatile write which stalls the pipeline. The data is visible to other threads at the same time.
    
    Specified by:
    
    writeOrderedDouble in interface RandomDataOutput
    
    Parameters:
    
    offset - to write to
    
    v - value to write
  - readStopBit
```
public long readStopBit()
```
    Description copied from interface: RandomDataInput
    Reads between one and ten bytes with are stop encoded with support for negative numbers
```
 long l = 0, b;
 int count = 0;
 while ((b = readByte()) < 0) {
     l |= (b & 0x7FL) << count;
     count += 7;
 }
 if (b == 0 && count > 0)
     return ~l;
 return l | (b << count);
 
```
    Specified by:
    
    readStopBit in interface RandomDataInput
    
    Returns:
    
    a stop bit encoded number as a long.
  - busyLockLong
```
public void busyLockLong(long offset)
                  throws InterruptedException,
                         IllegalStateException
```
    Description copied from interface: RandomDataUpdate
    
    Lock across processes
    Lock which uses 8 bytes. It store the lower 32 bits of the Thread Id, 16 bits are the process id and the re-entrant count as 16 bit. This means if you create more than 16 million threads you can get a collision, and if you try to re-enter 65535 times you will get an ISE
    
    Specified by:
    
    busyLockLong in interface RandomDataUpdate
    
    Parameters:
    
    offset - of the start of the 8-byte lock
    
    Throws:
    
    InterruptedException - if interrupted
    
    IllegalStateException - if the thread tries to lock it 65535 nested time (without an unlock)
  - writeDouble
```
public void writeDouble(double v)
```
    Description copied from interface: RandomDataOutput
    
    Writes a double value, which is comprised of eight bytes, to the output stream. It does this as if it first converts this double value to a long in exactly the manner of the Double.doubleToLongBits method and then writes the long value in exactly the manner of the writeLong method. The bytes written by this method may be read by the readDouble method of interface DataInput, which will then return a double equal to v.
    
    Specified by:
    
    writeDouble in interface DataOutput
    
    Specified by:
    
    writeDouble in interface RandomDataOutput
    
    Parameters:
    
    v - the double value to be written.
  - readDouble
```
public double readDouble(long offset)
```
    Description copied from interface: RandomDataInput
    
    Reads eight input bytes and returns a double value. It does this by first constructing a long value in exactly the manner of the readLong method, then converting this long value to a double in exactly the manner of the method Double.longBitsToDouble. This method is suitable for reading bytes written by the writeDouble method of interface DataOutput.
    
    Specified by:
    
    readDouble in interface RandomDataInput
    
    Parameters:
    
    offset - to read from
    
    Returns:
    
    the double value read.
  - addFloat
```
public float addFloat(long offset,
                      float f)
```
    Specified by:
    
    addFloat in interface RandomDataUpdate
  - skipTo
```
public boolean skipTo(@NotNull
                      StopCharTester tester)
```
    Description copied from interface: ByteStringParser
    
    Wind from this positionAddr to the end of the field
    
    Specified by:
    
    skipTo in interface ByteStringParser
    
    Parameters:
    
    tester - to stop at
    
    Returns:
    
    true if we stopped at a stop character, false if we ran out of data.
  - writeChar
```
public void writeChar(int v)
```
    Description copied from interface: RandomDataOutput
    Writes a char value, which is comprised of two bytes, to the output stream. The byte values to be written, in the order shown for big endian machines and the opposite for little endian, are:
```
 (byte)(0xff & (v >> 8))
 (byte)(0xff & v)
 
```
    The bytes written by this method may be read by the readChar method of interface DataInput , which will then return a char equal to (char)v.
    Specified by:
    
    writeChar in interface DataOutput
    
    Specified by:
    
    writeChar in interface RandomDataOutput
    
    Parameters:
    
    v - the char value to be written.
  - writeInt
```
public void writeInt(long offset,
                     int v)
```
    Description copied from interface: RandomDataOutput
    Writes an int value, which is comprised of four bytes, to the output stream. The byte values to be written, in the order shown for big endian machines and the opposite for little endian, are:
```
 (byte)(0xff & (v >> 24))
 (byte)(0xff & (v >> 16))
 (byte)(0xff & (v >>    8))
 (byte)(0xff & v)
 
```
    The bytes written by this method may be read by the readInt method of interface DataInput , which will then return an int equal to v.
    Specified by:
    
    writeInt in interface RandomDataOutput
    
    Parameters:
    
    offset - to be written to
    
    v - the int value to be written.
  - outputStream
```
@NotNull
public OutputStream outputStream()
```
    Specified by:
    
    outputStream in interface BytesCommon
    
    Returns:
    
    these Bytes as an OutputStream
  - compareAndSwapDouble
```
public boolean compareAndSwapDouble(long offset,
                                    double expected,
                                    double x)
```
    Description copied from interface: RandomDataOutput
    
    Perform a compare and set operation. The value is set to x provided the expected value is set already. This operation is atomic.
    
    Specified by:
    
    compareAndSwapDouble in interface RandomDataOutput
    
    Parameters:
    
    offset - to write to.
    
    expected - to expect
    
    x - to set if expected was found
    
    Returns:
    
    true if set, false if the value was not expected
  - file
```
public File file()
```
    Specified by:
    
    file in interface BytesStore
  - readList
```
public <E> void readList(@NotNull
                         Collection<E> list,
                         @NotNull
                         Class<E> eClass)
```
    Description copied from interface: RandomDataInput
    
    Read a stop bit encoded length and populates this Collection after zeroOut()ing it.
    This is suitable to reading a list written using writeList() in the RandomDataOutput interface
    
    Specified by:
    
    readList in interface RandomDataInput
    
    Type Parameters:
    
    E - the list element class
    
    Parameters:
    
    list - to populate
    
    eClass - the list element class
  - writeUnsignedByte
```
public void writeUnsignedByte(int v)
```
    Description copied from interface: RandomDataOutput
    
    Writes to the output stream the eight low- order bits of the argument v. The 24 high-order bits of v are ignored. (This means that writeByte does exactly the same thing as write for an integer argument.) The byte written by this method may be read by the readUnsignedByte method of interface DataInput, which will then return a byte equal to (byte)v.
    
    Specified by:
    
    writeUnsignedByte in interface RandomDataOutput
    
    Parameters:
    
    v - the byte value to be written.
  - readInt24
```
public int readInt24(long offset)
```
    Description copied from interface: RandomDataInput
    Reads three input bytes and returns a 24-bit int value. Let a-c be the first through third bytes read on big endian machines, and the opposite on little endian machines. The value returned is:
```
 
 ((((a & 0xff) << 24) | ((b & 0xff) << 16) | ((c & 0xff) << 8))) >> 8
 
```
    This method is suitable for reading bytes written by the writeInt24 method of interface RandomDataOutput.
    Specified by:
    
    readInt24 in interface RandomDataInput
    
    Parameters:
    
    offset - to read from
    
    Returns:
    
    the int value read.
  - readInt48
```
public long readInt48()
```
    Description copied from interface: RandomDataInput
    Reads six input bytes and returns a long value. Let a-f be the first through sixth bytes read on big endian machines, and the opposite on little endian machines. The value returned is:
```
 
 (((long)(a & 0xff) << 56) |
  ((long)(b & 0xff) << 48) |
  ((long)(c & 0xff) << 40) |
  ((long)(d & 0xff) << 32) |
  ((long)(e & 0xff) << 24) |
  ((long)(f & 0xff) << 16)) >> 16
 
```
    This method is suitable for reading bytes written by the writeInt48 method of interface RandomDataOutput.
    Specified by:
    
    readInt48 in interface RandomDataInput
    
    Returns:
    
    the long value read.
  - write
```
public void write(@NotNull
                  char[] data)
```
    Specified by:
    
    write in interface RandomDataOutput
  - readObject
```
@Nullable
public Object readObject()
                            throws IllegalStateException
```
    Description copied from interface: RandomDataInput
    
    Read and return an object. The class that implements this interface defines where the object is "read" from.
    
    Specified by:
    
    readObject in interface ObjectInput
    
    Specified by:
    
    readObject in interface RandomDataInput
    
    Returns:
    
    the object read from the stream
    
    Throws:
    
    IllegalStateException - the class of a serialized object cannot be found or any of the usual Input/Output related exceptions occur.
  - append
```
@NotNull
public ByteStringAppender append(@Nullable
                                          Enum value)
```
    Specified by:
    
    append in interface ByteStringAppender
  - parseUtf8
```
@NotNull
public String parseUtf8(@NotNull
                                 StopCharTester tester)
                          throws BufferUnderflowException
```
    Specified by:
    
    parseUtf8 in interface ByteStringParser
    
    Throws:
    
    BufferUnderflowException
  - readInt
```
public int readInt()
```
    Description copied from interface: RandomDataInput
    Reads four input bytes and returns an int value. Let a-d be the first through fourth bytes read on big endian machines, and the opposite on little endian machines. The value returned is:
```
 
 (((a & 0xff) << 24) | ((b & 0xff) << 16) | ((c & 0xff) << 8) | (d & 0xff))
 
```
    This method is suitable for reading bytes written by the writeInt method of interface DataOutput.
    Specified by:
    
    readInt in interface DataInput
    
    Specified by:
    
    readInt in interface RandomDataInput
    
    Returns:
    
    the int value read.
  - write
```
public void write(@NotNull
                  char[] data,
                  int off,
                  int len)
```
    Specified by:
    
    write in interface RandomDataOutput
  - addUnsignedShort
```
public int addUnsignedShort(long offset,
                            int i)
```
    Specified by:
    
    addUnsignedShort in interface RandomDataUpdate
  - readFloat
```
public float readFloat()
```
    Description copied from interface: RandomDataInput
    
    Reads four input bytes and returns a float value. It does this by first constructing an int value in exactly the manner of the readInt method, then converting this int value to a float in exactly the manner of the method Float.intBitsToFloat. This method is suitable for reading bytes written by the writeFloat method of interface DataOutput.
    
    Specified by:
    
    readFloat in interface DataInput
    
    Specified by:
    
    readFloat in interface RandomDataInput
    
    Returns:
    
    the float value read.
  - available
```
public int available()
```
    Specified by:
    
    available in interface ObjectInput
    
    Specified by:
    
    available in interface RandomDataInput
    
    Returns:
    
    remaining() or Integer.MAX_VALUE if larger.
  - position
```
public long position()
```
    Specified by:
    
    position in interface BytesCommon
    
    Returns:
    
    the offset read/written which must be >= limit()
  - addDouble
```
public double addDouble(long offset,
                        double d)
```
    Specified by:
    
    addDouble in interface RandomDataUpdate
  - write
```
public void write(int b)
```
    Description copied from interface: RandomDataOutput
    
    Writes to the output stream the eight low-order bits of the argument b. The 24 high-order bits of b are ignored.
    
    Specified by:
    
    write in interface DataOutput
    
    Specified by:
    
    write in interface ObjectOutput
    
    Specified by:
    
    write in interface RandomDataOutput
    
    Parameters:
    
    b - the byte to be written.
  - skipBytes
```
public int skipBytes(int n)
```
    Description copied from interface: RandomDataInput
    
    Makes an attempt to skip over n bytes of data from the input stream, discarding the skipped bytes. However, it may skip over some smaller number of bytes, possibly zero. This may result from any of a number of conditions; reaching end of file before n bytes have been skipped is only one possibility. This method never throws an EOFException. The actual number of bytes skipped is returned.
    
    Specified by:
    
    skipBytes in interface DataInput
    
    Specified by:
    
    skipBytes in interface RandomDataInput
    
    Parameters:
    
    n - the number of bytes to be skipped.
    
    Returns:
    
    the number of bytes actually skipped.
  - readCompactShort
```
public short readCompactShort()
```
    Description copied from interface: RandomDataInput
    
    Reads one or three input bytes and returns a short value. Let a be the first byte read. This mapped as follows; Byte.MIN_VALUE => Short.MIN_VALUE, Byte.MAX_VALUE => Short.MAX_VALUE, Byte.MIN_VALUE+2 to Byte.MAX_VALUE-1 => same as short value, Byte.MIN_VALUE+1 => readShort().
    This method is suitable for reading the bytes written by the writeCompactShort method of interface RandomDataOutput.
    
    Specified by:
    
    readCompactShort in interface RandomDataInput
    
    Returns:
    
    the 16-bit value read.
  - write
```
public void write(long offset,
                  byte[] byteArray)
```
    Description copied from interface: RandomDataOutput
    
    Writes to the output stream all the bytes in array bytes. If bytes is null, a NullPointerException is thrown. If bytes.length is zero, then no bytes are written. Otherwise, the byte bytes[0] is written first, then bytes[1], and so on; the last byte written is bytes[bytes.length-1].
    
    Specified by:
    
    write in interface RandomDataOutput
    
    Parameters:
    
    offset - to be written
    
    byteArray - the data.
  - writeList
```
public <E> void writeList(@NotNull
                          Collection<E> list)
```
    Description copied from interface: RandomDataOutput
    
    Write an ordered collection of "enumerable objects" (See writeEnum). This writes the stop bit encoded length, followed by multiple calls to writeEnum All the elements must be of the same type.
    This can be read by the readList method of RandomInputStream and the reader must know the type of each element. You can send the class first by using writeEnum of the element class
    
    Specified by:
    
    writeList in interface RandomDataOutput
    
    Type Parameters:
    
    E - the class of the list elements
    
    Parameters:
    
    list - to be written
  - read
```
public int read(@NotNull
                byte[] byteArray,
                int off,
                int len)
```
    Description copied from interface: RandomDataInput
    
    Reads into an array of bytes. This method will block until some input is available.
    
    Specified by:
    
    read in interface ObjectInput
    
    Specified by:
    
    read in interface RandomDataInput
    
    Parameters:
    
    byteArray - the buffer into which the data is read
    
    off - the start offset of the data
    
    len - the maximum number of bytes read
    
    Returns:
    
    the actual number of bytes read, -1 is returned when the end of the stream is reached.
  - readInt
```
public int readInt(long offset)
```
    Description copied from interface: RandomDataInput
    Reads four input bytes and returns an int value. Let a-d be the first through fourth bytes read on big endian machines, and the opposite on little endian machines. The value returned is:
```
 
 (((a & 0xff) << 24) | ((b & 0xff) << 16) | ((c & 0xff) << 8) | (d & 0xff))
 
```
    This method is suitable for reading bytes written by the writeInt method of interface RandomDataOutput.
    Specified by:
    
    readInt in interface RandomDataInput
    
    Parameters:
    
    offset - to read from
    
    Returns:
    
    the int value read.
  - writeFloat
```
public void writeFloat(long offset,
                       float v)
```
    Description copied from interface: RandomDataOutput
    
    Writes a float value, which is comprised of four bytes, to the output stream. It does this as if it first converts this float value to an int in exactly the manner of the Float.floatToIntBits method and then writes the int value in exactly the manner of the writeInt method. The bytes written by this method may be read by the readFloat method of interface DataInput, which will then return a float equal to v.
    
    Specified by:
    
    writeFloat in interface RandomDataOutput
    
    Parameters:
    
    offset - to write to
    
    v - the float value to be written.
  - parseLong
```
public long parseLong()
               throws BufferUnderflowException
```
    Specified by:
    
    parseLong in interface ByteStringParser
    
    Returns:
    
    the next long, stopping at the first invalid character
    
    Throws:
    
    BufferUnderflowException
  - readUnsignedByte
```
public int readUnsignedByte(long offset)
```
    Description copied from interface: RandomDataInput
    
    Reads one input byte, zero-extends it to type int, and returns the result, which is therefore in the range 0 through 255. This method is suitable for reading the byte written by the writeByte method of interface RandomDataOutput if the argument to writeByte was intended to be a value in the range 0 through 255.
    
    Specified by:
    
    readUnsignedByte in interface RandomDataInput
    
    Parameters:
    
    offset - of byte to read
    
    Returns:
    
    the unsigned 8-bit value read.
  - slice
```
public Bytes slice(long offset,
                   long length)
```
    Description copied from interface: BytesCommon
    
    Creates a new bytes whose content is a shared subsequence of this bytes' content.
    The content of the new bytes will start at this bytes' current BytesCommon.position()+ offset. Changes to this bytes' content will be visible in the new bytes, and vice versa; the two bytes' position and limit values will be independent.
    The new bytes' position will be zero, its capacity and its limit will be equal to length.
    offset can be negative (if current bytes' position is positive) and length can run out of current bytes' limit, the restriction is that new bytes' should be within this bytes' absolute bounds.
    
    Specified by:
    
    slice in interface BytesCommon
    
    Parameters:
    
    offset - relative offset of the new bytes from the current bytes' position
    
    length - capacity of the new bytes
    
    Returns:
    
    the new bytes
    
    See Also:
    
    BytesCommon.slice()
  - writeObject
```
public void writeObject(@Nullable
                        Object object)
```
    Description copied from interface: RandomDataOutput
    
    Write an object as either an "enumerable object" or a Serializable/Externalizable object using Java Serialization. Java Serialization is much slower but sometimes more convenient than using BytesMarshallable.
    
    Specified by:
    
    writeObject in interface ObjectOutput
    
    Specified by:
    
    writeObject in interface RandomDataOutput
    
    Parameters:
    
    object - to write
  - length
```
public int length()
```
    Specified by:
    
    length in interface CharSequence
  - readChar
```
public char readChar()
```
    Description copied from interface: RandomDataInput
    Reads two input bytes and returns a char value. Let a be the first byte read and b be the second byte on big endian machines, and the opposite on little endian machines. The value returned is:
```
(char)((a << 8) | (b & 0xff))
 
```
    This method is suitable for reading bytes written by the writeChar method of interface DataOutput.
    Specified by:
    
    readChar in interface DataInput
    
    Specified by:
    
    readChar in interface RandomDataInput
    
    Returns:
    
    the char value read.
  - read
```
public int read()
```
    Description copied from interface: RandomDataInput
    
    Reads a byte of data. This method is non blocking.
    
    Specified by:
    
    read in interface ObjectInput
    
    Specified by:
    
    read in interface RandomDataInput
    
    Returns:
    
    the byte read, or -1 if the end of the stream is reached.
  - writeBoolean
```
public void writeBoolean(long offset,
                         boolean v)
```
    Description copied from interface: RandomDataOutput
    
    Writes a boolean value to this output stream. If the argument v is true, the value (byte)1 is written; if v is false, the value (byte)0 is written. The byte written by this method may be read by the readBoolean method of interface DataInput, which will then return a boolean equal to v.
    
    Specified by:
    
    writeBoolean in interface RandomDataOutput
    
    Parameters:
    
    offset - to write boolean
    
    v - the boolean to be written.
  - parseDouble
```
public double parseDouble()
                   throws BufferUnderflowException
```
    Specified by:
    
    parseDouble in interface ByteStringParser
    
    Throws:
    
    BufferUnderflowException
  - writeCompactDouble
```
public void writeCompactDouble(double v)
```
    Description copied from interface: RandomDataOutput
    Writes four or twelve bytes as follow;
```
 if ((float) d == d) {
     writeFloat((float) d);
 } else {
     writeFloat(Float.NaN);
     writeDouble(d);
 }
 
```
    The bytes written by this method may be read by the readCompactDouble method of interface RandomDataInput , which will then return a double equal to v.
    Specified by:
    
    writeCompactDouble in interface RandomDataOutput
    
    Parameters:
    
    v - the double value to be written.
  - addAtomicFloat
```
public float addAtomicFloat(long offset,
                            float f)
```
    Specified by:
    
    addAtomicFloat in interface RandomDataUpdate
  - selfTerminating
```
public void selfTerminating(boolean selfTerminate)
```
    Description copied from interface: ByteStringParser
    
    If set to true, the end of the Bytes will be the end of any consuming String, double or long. If false, incomplete reads will throw a BufferUnderflowException
    
    Specified by:
    
    selfTerminating in interface ByteStringParser
    
    Parameters:
    
    selfTerminate - if true, the end of the Buffer is silent.
  - readCompactUnsignedInt
```
public long readCompactUnsignedInt()
```
    Description copied from interface: RandomDataInput
    
    Reads two or six input bytes and returns an int value. Let a be the first short read with readShort(). This mapped as follows; -1 => readUnsignedInt(), default => (a & 0xFFFF)
    This method is suitable for reading the bytes written by the writeCompactUnsignedInt method of interface RandomDataOutput.
    
    Specified by:
    
    readCompactUnsignedInt in interface RandomDataInput
    
    Returns:
    
    the unsigned 32-bit value read.
  - readVolatileDouble
```
public double readVolatileDouble(long offset)
```
    Description copied from interface: RandomDataInput
    
    This is the same as readDouble() except a read barrier is performed first.
    Reads four input bytes and returns a float value.
    This method is suitable for reading bytes written by the writeOrderedFloat method of interface RandomDataOutput.
    
    Specified by:
    
    readVolatileDouble in interface RandomDataInput
    
    Parameters:
    
    offset - to read from
    
    Returns:
    
    the int value read.
  - addLong
```
public long addLong(long offset,
                    long i)
```
    Specified by:
    
    addLong in interface RandomDataUpdate
  - readLong
```
public long readLong(long offset)
```
    Description copied from interface: RandomDataInput
    Reads eight input bytes and returns a long value. Let a-h be the first through eighth bytes read on big endian machines, and the opposite on little endian machines. The value returned is:
```
 
 (((long)(a & 0xff) << 56) |
  ((long)(b & 0xff) << 48) |
  ((long)(c & 0xff) << 40) |
  ((long)(d & 0xff) << 32) |
  ((long)(e & 0xff) << 24) |
  ((long)(f & 0xff) << 16) |
  ((long)(g & 0xff) <<  8) |
  ((long)(h & 0xff)))
 
```
    This method is suitable for reading bytes written by the writeLong method of interface RandomDataOutput.
    Specified by:
    
    readLong in interface RandomDataInput
    
    Parameters:
    
    offset - of the long to read
    
    Returns:
    
    the long value read.
  - compareAndSwapInt
```
public boolean compareAndSwapInt(long offset,
                                 int expected,
                                 int x)
```
    Description copied from interface: RandomDataOutput
    
    Perform a compare and set operation. The value is set to x provided the expected value is set already. This operation is atomic.
    
    Specified by:
    
    compareAndSwapInt in interface RandomDataOutput
    
    Parameters:
    
    offset - to write to.
    
    expected - to expect
    
    x - to set if expected was found
    
    Returns:
    
    true if set, false if the value was not expected
  - append
```
@NotNull
public ByteStringAppender append(@NotNull
                                          CharSequence s)
```
    Specified by:
    
    append in interface Appendable
    
    Specified by:
    
    append in interface ByteStringAppender
  - append
```
@NotNull
public ByteStringAppender append(int i)
```
    Specified by:
    
    append in interface ByteStringAppender
  - writeMap
```
public <K,V> void writeMap(@NotNull
                           Map<K,V> map)
```
    Description copied from interface: RandomDataOutput
    
    Write the keys and values of a Map of "enumerable objects" (See writeEnum). This writes the stop bit encoded length, followed by multiple calls to writeEnum for each key and value. All the keys must be of the same type. All values must be of the same type.
    
    Specified by:
    
    writeMap in interface RandomDataOutput
    
    Type Parameters:
    
    K - the class of the map keys
    
    V - the class of the map values
    
    Parameters:
    
    map - to write out
  - parseBoolean
```
public Boolean parseBoolean(@NotNull
                            StopCharTester tester)
                     throws BufferUnderflowException
```
    Description copied from interface: ByteStringParser
    
    Return true or false, or null if it could not be detected as true or false. Case is not important
    false: f, false, n, no, 0
    true: t, true, y, yes, 1
    
    Specified by:
    
    parseBoolean in interface ByteStringParser
    
    Parameters:
    
    tester - to detect the end of the text.
    
    Returns:
    
    true, false, or null if neither.
    
    Throws:
    
    BufferUnderflowException
  - tryRWReadLock
```
public boolean tryRWReadLock(long offset,
                             long timeOutNS)
                      throws IllegalStateException,
                             InterruptedException
```
    Description copied from interface: RandomDataUpdate
    
    Uses the 64-bit long at the offset as a non-reentrant read/write lock. There can be up to 2^20-1 threads reading, or waiting to read on a lock.
    
    Specified by:
    
    tryRWReadLock in interface RandomDataUpdate
    
    Parameters:
    
    offset - of the long monitor
    
    timeOutNS - length of time to busy wait for the lock.
    
    Returns:
    
    if the lock could be obtained in time.
    
    Throws:
    
    IllegalStateException - if the monitor is in an illegal state
    
    InterruptedException
  - readUnsignedShort
```
public int readUnsignedShort(long offset)
```
    Description copied from interface: RandomDataInput
    Reads two input bytes and returns an int value in the range 0 through 65535. Let a be the first byte read and b be the second byte on big endian machines, and the opposite on little endian machines. The value returned is:
```
     (((a & 0xff) << 8) | (b & 0xff))
 
```
    This method is suitable for reading the bytes written by the writeShort method of interface RandomDataOutput if the argument to writeUnsignedShort was intended to be a value in the range 0 through 65535.
    Specified by:
    
    readUnsignedShort in interface RandomDataInput
    
    Parameters:
    
    offset - of short to read.
    
    Returns:
    
    the unsigned 16-bit value read.
  - writeUTFΔ
```
public void writeUTFΔ(long offset,
                      int maxSize,
                      @Nullable
                      CharSequence s)
               throws IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Write the same encoding as writeUTF with the following changes. 1) The length is stop bit encoded i.e. one byte longer for short strings, but is not limited in length. 2) The string can be null.
    
    Specified by:
    
    writeUTFΔ in interface RandomDataOutput
    
    Parameters:
    
    offset - to write to
    
    maxSize - maximum number of bytes to use
    
    s - the string value to be written. Can be null.
    
    Throws:
    
    IllegalStateException - if the size is too large.
  - readByte
```
public byte readByte(long offset)
```
    Description copied from interface: RandomDataInput
    
    Reads and returns one input byte. The byte is treated as a signed value in the range -128 through 127, inclusive. This method is suitable for reading the byte written by the writeByte method of interface RandomDataOutput.
    
    Specified by:
    
    readByte in interface RandomDataInput
    
    Parameters:
    
    offset - of byte to read.
    
    Returns:
    
    the 8-bit value read.
  - append
```
@NotNull
public ByteStringAppender append(long l)
```
    Specified by:
    
    append in interface ByteStringAppender
  - writeUTFΔ
```
public void writeUTFΔ(@Nullable
                      CharSequence s)
```
    Description copied from interface: RandomDataOutput
    
    Write the same encoding as writeUTF with the following changes. 1) The length is stop bit encoded i.e. one byte longer for short strings, but is not limited in length. 2) The string can be null.
    
    Specified by:
    
    writeUTFΔ in interface RandomDataOutput
    
    Parameters:
    
    s - the string value to be written. Can be null.
  - compareAndSwapLong
```
public boolean compareAndSwapLong(long offset,
                                  long expected,
                                  long x)
```
    Description copied from interface: RandomDataOutput
    
    Perform a compare and set operation. The value is set to x provided the expected value is set already. This operation is atomic.
    
    Specified by:
    
    compareAndSwapLong in interface RandomDataOutput
    
    Parameters:
    
    offset - to write to.
    
    expected - to expect
    
    x - to set if expected was found
    
    Returns:
    
    true if set, false if the value was not expected
  - writeCompactShort
```
public void writeCompactShort(int v)
```
    Description copied from interface: RandomDataOutput
    
    Writes one or three bytes as follows; Short.MIN_VALUE => Byte.MIN_VALUE, Short.MAX_VALUE => Byte.MAX_VALUE, Short.MIN_VALUE+2 to Short.MAX_VALUE-1 => writeByte(x), default => writeByte(Byte.MIN_VALUE+1; writeShort(x)
    The bytes written by this method may be read by the readCompactShort method of interface RandomDataInput , which will then return a short equal to (short)v.
    
    Specified by:
    
    writeCompactShort in interface RandomDataOutput
    
    Parameters:
    
    v - the short value to be written.
  - bytes
```
public Bytes bytes()
```
    Description copied from interface: BytesStore
    
    Create a bytes whose content is the whole bytes store. Call of this method is equivalent to bytes(0, size()) call.
    
    Specified by:
    
    bytes in interface BytesStore
    
    Returns:
    
    the new bytes
    
    See Also:
    
    BytesStore.bytes(long, long)
  - write
```
public void write(byte[] byteArray)
```
    Description copied from interface: RandomDataOutput
    
    Writes to the output stream all the bytes in array bytes. If bytes is null, a NullPointerException is thrown. If bytes.length is zero, then no bytes are written. Otherwise, the byte bytes[0] is written first, then bytes[1], and so on; the last byte written is bytes[bytes.length-1].
    
    Specified by:
    
    write in interface DataOutput
    
    Specified by:
    
    write in interface ObjectOutput
    
    Specified by:
    
    write in interface RandomDataOutput
    
    Parameters:
    
    byteArray - the data.
  - unlockInt
```
public void unlockInt(long offset)
               throws IllegalMonitorStateException
```
    Description copied from interface: RandomDataUpdate
    
    Lock which uses 4 bytes. Unlock this It store the lower 24 bits of the Thread Id and the re-entrant count as 8 bit. This means if you create more than 16 million threads you can get a collision, and if you try to re-enter 255 times you will get an ISE
    
    Specified by:
    
    unlockInt in interface RandomDataUpdate
    
    Parameters:
    
    offset - of the start of the 4-byte lock
    
    Throws:
    
    IllegalMonitorStateException - if this thread doesn't hold the lock
  - tryLockLong
```
public boolean tryLockLong(long offset)
```
    Description copied from interface: RandomDataUpdate
    
    Lock across processes
    Lock which uses 8 bytes. It store the lower 32 bits of the Thread Id, 16 bits are the process id and the re-entrant count as 16 bit. This means if you create more than 16 million threads you can get a collision, and if you try to re-enter 65535 times you will get an ISE
    
    Specified by:
    
    tryLockLong in interface RandomDataUpdate
    
    Parameters:
    
    offset - of the start of the 8-byte lock
    
    Returns:
    
    did it lock or not.
  - readByte
```
public byte readByte()
```
    Description copied from interface: RandomDataInput
    
    Reads and returns one input byte. The byte is treated as a signed value in the range -128 through 127, inclusive. This method is suitable for reading the byte written by the writeByte method of interface DataOutput.
    
    Specified by:
    
    readByte in interface DataInput
    
    Specified by:
    
    readByte in interface RandomDataInput
    
    Returns:
    
    the 8-bit value read.
  - tryRWWriteLock
```
public boolean tryRWWriteLock(long offset,
                              long timeOutNS)
                       throws IllegalStateException,
                              InterruptedException
```
    Description copied from interface: RandomDataUpdate
    
    Uses the 64-bit long at the offset as a non-reentrant read/write lock. There can be up to 2^20-1 threads reading, or waiting to read on a lock.
    
    Specified by:
    
    tryRWWriteLock in interface RandomDataUpdate
    
    Parameters:
    
    offset - of the long monitor
    
    timeOutNS - length of time to busy wait for the lock.
    
    Returns:
    
    if the lock could be obtained in time.
    
    Throws:
    
    IllegalStateException - if the monitor is in an illegal state
    
    InterruptedException
  - write
```
public void write(byte[] byteArray,
                  int off,
                  int len)
```
    Description copied from interface: RandomDataOutput
    
    Writes len bytes from array bytes, in order, to the output stream. If bytes is null, a NullPointerException is thrown. If off is negative, or len is negative, or off+len is greater than the length of the array bytes, then an IndexOutOfBoundsException is thrown. If len is zero, then no bytes are written. Otherwise, the byte bytes[off] is written first, then bytes[off+1], and so on; the last byte written is bytes[off+len-1].
    
    Specified by:
    
    write in interface DataOutput
    
    Specified by:
    
    write in interface ObjectOutput
    
    Specified by:
    
    write in interface RandomDataOutput
    
    Parameters:
    
    byteArray - the data.
    
    off - the start offset in the data.
    
    len - the number of bytes to write.
  - writeUTF
```
public void writeUTF(@NotNull
                     String s)
```
    Description copied from interface: RandomDataOutput
    Writes two bytes of length information to the output stream, followed by the modified UTF-8 representation of every character in the string s. If s is null, a NullPointerException is thrown. Each character in the string s is converted to a group of one, two, or three bytes, depending on the value of the character.
    If a character c is in the range \u0001 through \u007f, it is represented by one byte:
```
(byte)c 
```
    If a character c is \u0000 or is in the range \u0080 through \u07ff, then it is represented by two bytes, to be written in the order shown:
```
 (byte)(0xc0 | (0x1f & (c >> 6)))
 (byte)(0x80 | (0x3f & c))
  
```
    If a character c is in the range \u0800 through uffff, then it is represented by three bytes, to be written in the order shown:
```
 (byte)(0xe0 | (0x0f & (c >> 12)))
 (byte)(0x80 | (0x3f & (c >>  6)))
 (byte)(0x80 | (0x3f & c))
  
```
    First, the total number of bytes needed to represent all the characters of s is calculated. If this number is larger than 65535, then a UTFDataFormatException is thrown. Otherwise, this length is written to the output stream in exactly the manner of the writeShort method; after this, the one-, two-, or three-byte representation of each character in the string s is written.
    The bytes written by this method may be read by the readUTF method of interface DataInput , which will then return a String equal to s.
    Specified by:
    
    writeUTF in interface DataOutput
    
    Specified by:
    
    writeUTF in interface RandomDataOutput
    
    Parameters:
    
    s - the string value to be written. Cannot be null
  - load
```
public Bytes load()
```
    Description copied from interface: BytesCommon
    
    Access every page to ensure those pages are in memory.
    
    Specified by:
    
    load in interface BytesCommon
    
    Returns:
    
    this.
  - getAndAdd
```
public int getAndAdd(long offset,
                     int delta)
```
    Description copied from interface: RandomDataOutput
    
    Atomically adds the given value to the current value.
    
    Specified by:
    
    getAndAdd in interface RandomDataOutput
    
    Parameters:
    
    offset - of the int value to use.
    
    delta - the value to add
    
    Returns:
    
    the previous value
  - readShort
```
public short readShort(long offset)
```
    Description copied from interface: RandomDataInput
    Reads two input bytes and returns a short value. Let a be the first byte read and b be the second byte on big endian machines, and the opposite on little endian machines. The value returned is:
```
     (short)((a << 8) | (b & 0xff))
 
```
    This method is suitable for reading the bytes written by the writeShort method of interface RandomDataOutput.
    Specified by:
    
    readShort in interface RandomDataInput
    
    Parameters:
    
    offset - of short to read.
    
    Returns:
    
    the 16-bit value read.
  - stepBackAndSkipTo
```
public boolean stepBackAndSkipTo(@NotNull
                                 StopCharTester tester)
```
    Description copied from interface: ByteStringParser
    
    Make sure we just read a stop character
    
    Specified by:
    
    stepBackAndSkipTo in interface ByteStringParser
    
    Parameters:
    
    tester - to stop at
    
    Returns:
    
    true if we stopped at a stop character, false if we ran out of data.
  - resetLockLong
```
public void resetLockLong(long offset)
```
    Description copied from interface: RandomDataUpdate
    
    Lock which uses 8 bytes. Reset forces the lock to be cleared. Use this only when the program believes the locked thread is dead.
    
    Specified by:
    
    resetLockLong in interface RandomDataUpdate
    
    Parameters:
    
    offset - of the start of the 8-byte lock
  - readVolatileInt
```
public int readVolatileInt(long offset)
```
    Description copied from interface: RandomDataInput
    This is the same as readInt() except a read barrier is performed first.
    Reads four input bytes and returns an int value. Let a-d be the first through fourth bytes read on big endian machines, and the opposite on little endian machines. The value returned is:
```
 
 (((a & 0xff) << 24) | ((b & 0xff) << 16) | ((c & 0xff) << 8) | (d & 0xff))
 
```
    This method is suitable for reading bytes written by the writeOrderedInt or writeVolatileInt method of interface RandomDataOutput.
    Specified by:
    
    readVolatileInt in interface RandomDataInput
    
    Parameters:
    
    offset - to read from
    
    Returns:
    
    the int value read.
  - byteOrder
```
@NotNull
public ByteOrder byteOrder()
```
    Specified by:
    
    byteOrder in interface BytesCommon
    
    Returns:
    
    Byte order for reading binary
  - bytes
```
public Bytes bytes(long offset,
                   long length)
```
    Description copied from interface: BytesStore
    
    Slice a Bytes object with start address of address+ offset and capacity of length.
    If this BytesStore is Bytes itself rather than natural BytesStore object, this method will offset the new bytes from the bytes' start, not from bytes' position like BytesCommon.slice(long, long).
    offset should be non-negative, length should be positive, offset + length should be less or equal to size.
    
    Specified by:
    
    bytes in interface BytesStore
    
    Parameters:
    
    offset - offset of the new bytes from the bytes store address
    
    length - capacity and limit of the new bytes
    
    Returns:
    
    the sliced Bytes
    
    See Also:
    
    BytesStore.bytes()
  - alignPositionAddr
```
public void alignPositionAddr(int alignment)
```
    Description copied from interface: BytesCommon
    
    Align the position address to a power of 2.
    
    Specified by:
    
    alignPositionAddr in interface BytesCommon
    
    Parameters:
    
    alignment - power of 2 to align to.
  - writeUnsignedShort
```
public void writeUnsignedShort(int v)
```
    Description copied from interface: RandomDataOutput
    Writes two bytes to the output stream to represent the value of the argument. The byte values to be written, in the order shown for big endian machines and the opposite for little endian, are:
```
 (byte)(0xff & (v >> 8))
 (byte)(0xff & v)
  
```
    The bytes written by this method may be read by the readUnsignedShort method of interface RandomDataInput , which will then return a short equal to (short)v.
    Specified by:
    
    writeUnsignedShort in interface RandomDataOutput
    
    Parameters:
    
    v - the unsigned short value to be written.
  - parseLong
```
public long parseLong(int base)
               throws BufferUnderflowException
```
    Specified by:
    
    parseLong in interface ByteStringParser
    
    Parameters:
    
    base - to use.
    
    Returns:
    
    the next long, stopping at the first invalid character
    
    Throws:
    
    BufferUnderflowException
  - readBoolean
```
public boolean readBoolean()
```
    Description copied from interface: RandomDataInput
    
    Reads one input byte and returns true if that byte is nonzero, false if that byte is zero. This method is suitable for reading the byte written by the writeBoolean method of interface DataOutput.
    
    Specified by:
    
    readBoolean in interface DataInput
    
    Specified by:
    
    readBoolean in interface RandomDataInput
    
    Returns:
    
    the boolean value read.
  - checkEndOfBuffer
```
public void checkEndOfBuffer()
                      throws IndexOutOfBoundsException
```
    Specified by:
    
    checkEndOfBuffer in interface BytesCommon
    
    Throws:
    
    IndexOutOfBoundsException - if the bounds of the Bytes has been exceeded.
  - readVolatileFloat
```
public float readVolatileFloat(long offset)
```
    Description copied from interface: RandomDataInput
    
    This is the same as readFloat() except a read barrier is performed first.
    Reads four input bytes and returns a float value.
    This method is suitable for reading bytes written by the writeOrderedFloat method of interface RandomDataOutput.
    
    Specified by:
    
    readVolatileFloat in interface RandomDataInput
    
    Parameters:
    
    offset - to read from
    
    Returns:
    
    the int value read.
  - parseDecimal
```
@NotNull
public MutableDecimal parseDecimal(@NotNull
                                            MutableDecimal decimal)
                                     throws BufferUnderflowException
```
    Specified by:
    
    parseDecimal in interface ByteStringParser
    
    Throws:
    
    BufferUnderflowException
  - addAtomicDouble
```
public double addAtomicDouble(long offset,
                              double d)
```
    Specified by:
    
    addAtomicDouble in interface RandomDataUpdate
  - unlockLong
```
public void unlockLong(long offset)
                throws IllegalMonitorStateException
```
    Description copied from interface: RandomDataUpdate
    
    Lock across processes
    Lock which uses 8 bytes. It store the lower 32 bits of the Thread Id, 16 bits are the process id and the re-entrant count as 16 bit. This means if you create more than 16 million threads you can get a collision, and if you try to re-enter 65535 times you will get an ISE
    
    Specified by:
    
    unlockLong in interface RandomDataUpdate
    
    Parameters:
    
    offset - of the start of the 8-byte lock
    
    Throws:
    
    IllegalMonitorStateException - if this thread doesn't hold the lock
  - writeFloat
```
public void writeFloat(float v)
```
    Description copied from interface: RandomDataOutput
    
    Writes a float value, which is comprised of four bytes, to the output stream. It does this as if it first converts this float value to an int in exactly the manner of the Float.floatToIntBits method and then writes the int value in exactly the manner of the writeInt method. The bytes written by this method may be read by the readFloat method of interface DataInput, which will then return a float equal to v.
    
    Specified by:
    
    writeFloat in interface DataOutput
    
    Specified by:
    
    writeFloat in interface RandomDataOutput
    
    Parameters:
    
    v - the float value to be written.
  - reserve
```
public void reserve()
```
    Specified by:
    
    reserve in interface ReferenceCounted
  - write
```
public void write(@NotNull
                  ByteBuffer bb)
```
    Description copied from interface: RandomDataOutput
    Copies the contents of a ByteBuffer from the position to the limit.
    This method transfers the bytes remaining in the given source buffer into this buffer. If there are more bytes remaining in the source buffer than in this buffer, that is, if src.remaining() > remaining(), then no bytes are transferred and a BufferOverflowException is thrown.
    Otherwise, this method copies n = src.remaining() bytes from the given buffer into this buffer, starting at each buffer's current position. The positions of both buffers are then incremented by n.
    In other words, an invocation of this method of the form dst.write(src) has exactly the same effect as the loop
```
     while (src.hasRemaining())
         dst.writeByte(src.get());
  
```
    Specified by:
    
    write in interface RandomDataOutput
    
    Parameters:
    
    bb - to copy.
  - threadIdForLockLong
```
public long threadIdForLockLong(long offset)
```
    Description copied from interface: RandomDataUpdate
    
    Lock which uses 8 bytes. This returns the lower bytes which contain the threadId.
    
    Specified by:
    
    threadIdForLockLong in interface RandomDataUpdate
    
    Parameters:
    
    offset - of the start of the 8-byte lock
    
    Returns:
    
    the threadId or 0 if no thread holds the lock.
  - writeChar
```
public void writeChar(long offset,
                      int v)
```
    Description copied from interface: RandomDataOutput
    Writes a char value, which is comprised of two bytes, to the output stream. The byte values to be written, in the order shown for big endian machines and the opposite for little endian, are:
```
 (byte)(0xff & (v >> 8))
 (byte)(0xff & v)
 
```
    The bytes written by this method may be read by the readChar method of interface DataInput , which will then return a char equal to (char)v.
    Specified by:
    
    writeChar in interface RandomDataOutput
    
    Parameters:
    
    offset - to be written to
    
    v - the char value to be written.
  - tryLockNanosLong
```
public boolean tryLockNanosLong(long offset,
                                long nanos)
```
    Description copied from interface: RandomDataUpdate
    
    Lock across processes
    Lock which uses 8 bytes. It store the lower 32 bits of the Thread Id, 16 bits are the process id and the re-entrant count as 16 bit. This means if you create more than 16 million threads you can get a collision, and if you try to re-enter 65535 times you will get an ISE
    
    Specified by:
    
    tryLockNanosLong in interface RandomDataUpdate
    
    Parameters:
    
    offset - of the start of the 8-byte lock
    
    nanos - to try to lock for
    
    Returns:
    
    did it lock or not.
  - addAtomicInt
```
public int addAtomicInt(long offset,
                        int i)
```
    Specified by:
    
    addAtomicInt in interface RandomDataUpdate
  - writeInstance
```
public <OBJ> void writeInstance(@NotNull
                                Class<OBJ> objClass,
                                @NotNull
                                OBJ obj)
```
    Description copied from interface: RandomDataOutput
    
    Write an object with the assumption that the objClass will be provided when the class is read.
    
    Specified by:
    
    writeInstance in interface RandomDataOutput
    
    Type Parameters:
    
    OBJ - the class of the object to write
    
    Parameters:
    
    objClass - class to write
    
    obj - to write
  - readFully
```
public void readFully(@NotNull
                      byte[] byteArray)
```
    Description copied from interface: RandomDataInput
    Reads some bytes from an input stream and stores them into the buffer array b. The number of bytes read is equal to the length of b.
    This method blocks until one of the following conditions occurs:
    - b.length bytes of input data are available, in which case a normal return is made.
    - End of file is detected, in which case an EOFException is thrown.
    - An I/O error occurs, in which case an IOException other than EOFException is thrown.
    If bytes is null, a NullPointerException is thrown. If bytes.length is zero, then no bytes are read. Otherwise, the first byte read is stored into element bytes[0], the next one into bytes[1], and so on. If an exception is thrown from this method, then it may be that some but not all bytes of bytes have been updated with data from the input stream.
    Specified by:
    
    readFully in interface DataInput
    
    Specified by:
    
    readFully in interface RandomDataInput
    
    Parameters:
    
    byteArray - the buffer into which the data is read.
  - position
```
public Bytes position(long position)
```
    Specified by:
    
    position in interface BytesCommon
    
    Parameters:
    
    position - to skip to
    
    Returns:
    
    this bytes object back
  - writeLong
```
public void writeLong(long offset,
                      long v)
```
    Description copied from interface: RandomDataOutput
    Writes a long value, which is comprised of eight bytes, to the output stream. The byte values to be written, in the order shown for big endian machines and the opposite for little endian, are:
```
 (byte)(0xff & (v >> 56))
 (byte)(0xff & (v >> 48))
 (byte)(0xff & (v >> 40))
 (byte)(0xff & (v >> 32))
 (byte)(0xff & (v >> 24))
 (byte)(0xff & (v >> 16))
 (byte)(0xff & (v >>  8))
 (byte)(0xff & v)
 
```
    The bytes written by this method may be read by the readLong method of interface DataInput , which will then return a long equal to v.
    Specified by:
    
    writeLong in interface RandomDataOutput
    
    Parameters:
    
    offset - to be written to
    
    v - the long value to be written.
  - readObject
```
public void readObject(Object object,
                       int start,
                       int end)
```
    Description copied from interface: RandomDataInput
    
    Read the object from start to end bytes
    
    Specified by:
    
    readObject in interface RandomDataInput
    
    Parameters:
    
    object - to read into
    
    start - byte inclusive
    
    end - byte exclusive
  - threadIdForLockInt
```
public int threadIdForLockInt(long offset)
```
    Description copied from interface: RandomDataUpdate
    
    Lock which uses 4 bytes. This returns the lower bytes which contain the threadId.
    
    Specified by:
    
    threadIdForLockInt in interface RandomDataUpdate
    
    Parameters:
    
    offset - of the start of the 4-byte lock
    
    Returns:
    
    the threadId or 0 if no thread holds the lock.
  - appendDateMillis
```
@NotNull
public ByteStringAppender appendDateMillis(long timeInMS)
```
    Specified by:
    
    appendDateMillis in interface ByteStringAppender
  - writeInt24
```
public void writeInt24(int v)
```
    Description copied from interface: RandomDataOutput
    Writes an int value, which is comprised of three bytes, to the output stream. The byte values to be written, in the order shown for big endian machines and the opposite for little endian, are:
```
 (byte)(0xff & (v >> 16))
 (byte)(0xff & (v >>    8))
 (byte)(0xff & v)
 
```
    The bytes written by this method may be read by the readInt24 method of interface RandomDataInput , which will then return an int equal to v.
    Specified by:
    
    writeInt24 in interface RandomDataOutput
    
    Parameters:
    
    v - the int value to be written.
  - startsWith
```
public boolean startsWith(RandomDataInput keyBytes)
```
    Specified by:
    
    startsWith in interface RandomDataInput
  - readUnsignedInt
```
public long readUnsignedInt()
```
    Description copied from interface: RandomDataInput
    Reads four input bytes and returns an int value. Let a-d be the first through fourth bytes read on big endian machines, and the opposite on little endian machines. The value returned is:
```
 
 ((((long) a & 0xff) << 24) | ((b & 0xff) << 16) | ((c & 0xff) << 8) | (d &
 0xff))
 
```
    This method is suitable for reading bytes written by the writeUnsignedInt method of interface RandomDataOutput.
    Specified by:
    
    readUnsignedInt in interface RandomDataInput
    
    Returns:
    
    the unsigned int value read.
  - limit
```
public Bytes limit(long limit)
```
    Specified by:
    
    limit in interface BytesCommon
    
    Parameters:
    
    limit - the new limit which must be >= capacity()
    
    Returns:
    
    this bytes object back
  - finish
```
public void finish()
```
    Description copied from interface: BytesCommon
    
    Mark the end of the message if writing and check we are at the end of the message if reading.
    
    Specified by:
    
    finish in interface BytesCommon
  - address
```
public long address()
```
    Specified by:
    
    address in interface BytesStore
  - tryLockInt
```
public boolean tryLockInt(long offset)
```
    Description copied from interface: RandomDataUpdate
    
    Lock which uses 4 bytes. It store the lower 24 bits of the Thread Id and the re-entrant count as 8 bit. This means if you create more than 16 million threads you can get a collision, and if you try to re-enter 255 times you will get an ISE
    
    Specified by:
    
    tryLockInt in interface RandomDataUpdate
    
    Parameters:
    
    offset - of the start of the 4-byte lock
    
    Returns:
    
    did it lock or not.
  - readVolatileLong
```
public long readVolatileLong(long offset)
```
    Description copied from interface: RandomDataInput
    This is the same readLong() except a dread barrier is performed first
    Reads eight input bytes and returns a long value. Let a-h be the first through eighth bytes read on big endian machines, and the opposite on little endian machines. The value returned is:
```
 
 (((long)(a & 0xff) << 56) |
  ((long)(b & 0xff) << 48) |
  ((long)(c & 0xff) << 40) |
  ((long)(d & 0xff) << 32) |
  ((long)(e & 0xff) << 24) |
  ((long)(f & 0xff) << 16) |
  ((long)(g & 0xff) <<  8) |
  ((long)(h & 0xff)))
 
```
    This method is suitable for reading bytes written by the writeOrderedLong or writeVolatileLong method of interface RandomDataOutput.
    Specified by:
    
    readVolatileLong in interface RandomDataInput
    
    Parameters:
    
    offset - of the long to read
    
    Returns:
    
    the long value read.
  - readUnsignedByte
```
public int readUnsignedByte()
```
    Description copied from interface: RandomDataInput
    
    Reads one input byte, zero-extends it to type int, and returns the result, which is therefore in the range 0 through 255. This method is suitable for reading the byte written by the writeByte method of interface DataOutput if the argument to writeByte was intended to be a value in the range 0 through 255.
    
    Specified by:
    
    readUnsignedByte in interface DataInput
    
    Specified by:
    
    readUnsignedByte in interface RandomDataInput
    
    Returns:
    
    the unsigned 8-bit value read.
  - readFully
```
public void readFully(long offset,
                      @NotNull
                      byte[] byteArray,
                      int off,
                      int len)
```
    Specified by:
    
    readFully in interface RandomDataInput
  - write
```
public void write(long offset,
                  byte[] byteArray,
                  int off,
                  int len)
```
    Specified by:
    
    write in interface RandomDataOutput
  - write
```
public void write(long offset,
                  Bytes bytes)
```
    Specified by:
    
    write in interface RandomDataOutput
  - read8bitText
```
public boolean read8bitText(@NotNull
                            StringBuilder stringBuilder)
                     throws StreamCorruptedException
```
    Specified by:
    
    read8bitText in interface RandomDataInput
    
    Throws:
    
    StreamCorruptedException
  - readEnum
```
public <E> E readEnum(long offset,
                      int maxSize,
                      Class<E> eClass)
```
    Specified by:
    
    readEnum in interface RandomDataInput
  - write8bitText
```
public void write8bitText(@Nullable
                          CharSequence s)
```
    Specified by:
    
    write8bitText in interface RandomDataOutput
  - writeEnum
```
public void writeEnum(long offset,
                      int len,
                      Object object)
```
    Specified by:
    
    writeEnum in interface RandomDataOutput

Class WrappedBytes<B extends Bytes>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface net.openhft.lang.io.RandomDataInput

Methods inherited from interface java.lang.CharSequence

Field Detail

wrapped

Constructor Detail

WrappedBytes

Method Detail

clearThreadAssociation

sliceAsByteBuffer

readMarshallable

toDebugString

toHexString

compare

readCompactLong

tryLockNanosInt

writeMarshallable

readInt24

flush

writeDouble

limit

appendTimeMillis

parseEnum

refCount

writeShort

writeEnum

append

writeCompactUnsignedShort

readVolatileLong

write

write

writeOrderedInt

readUTFΔ

writeInt48

readLong

readIncompleteLong

writeLong

appendDateTimeMillis

readEnum

write

append

toDebugString

isFinished

writeCompactUnsignedInt

append

readUnsignedByteOrThrow

zeroOut

zeroOut

writeShort

addShort

writeUnsignedInt

free

readUnsignedShort

writeStopBit

readObject

writeCompactInt

writeOrderedLong

addByte

readVolatileInt

close

read

read

append

skip

selfTerminating

writeBytes

size

readCompactUnsignedShort

append

writeCompactLong

readCompactDouble

writeOrderedInt

writeObject

asString

readUTFΔ

flip