AbstractBytes (OpenHFT/Java-Lang/lang 6.6.7 API)

java.lang.Object
- net.openhft.lang.io.AbstractBytes

All Implemented Interfaces:

DataInput, DataOutput, ObjectInput, ObjectOutput, Appendable, AutoCloseable, CharSequence, RandomAccess, Bytes, BytesCommon, BytesStore, ByteStringAppender, ByteStringParser, RandomDataInput, RandomDataOutput, RandomDataUpdate, BytesMarshallable, ReferenceCounted

Direct Known Subclasses:

ByteBufferBytes, MappedNativeBytes, NativeBytes
```
public abstract class AbstractBytes
extends Object
implements Bytes
```
Author:

peter.lawrey

Field Summary

Fields
Modifier and Type Field and Description

static int END_OF_BUFFER

protected boolean finished

static int SLEEP_THRESHOLD

static long UNSIGNED_INT_MASK

Fields
Modifier and Type	Field and Description
`static int`	`END_OF_BUFFER`
`protected boolean`	`finished`
`static int`	`SLEEP_THRESHOLD`
`static long`	`UNSIGNED_INT_MASK`

Method Summary

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 delta)`
`float`	`addAtomicFloat(long offset, float delta)`
`int`	`addAtomicInt(long offset, int i)`
`long`	`addAtomicLong(long offset, long delta)`
`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)`
`short`	`addShort(long offset, short s)`
`int`	`addUnsignedByte(long offset, int i)`
`long`	`addUnsignedInt(long offset, long i)`
`int`	`addUnsignedShort(long offset, int i)`
`ByteStringAppender`	`append(boolean b)` Writes "true" or "false".
`ByteStringAppender`	`append(char c)`
`ByteStringAppender`	`append(CharSequence str)`
`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 num)`
`<E> ByteStringAppender`	`append(Iterable<E> list, CharSequence separator)`
`ByteStringAppender`	`append(long num)`
`ByteStringAppender`	`append(long num, 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
`char`	`charAt(int index)`
`protected abstract void`	`cleanup()`
`AbstractBytes`	`clear()` Clears this buffer.
`void`	`clearThreadAssociation()` clearing the volatile singleThread is a write barrier.
`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 value)` Perform a compare and set operation.
`protected boolean`	`compareRest(String s)`
`File`	`file()`
`static long`	`findUTFLength(CharSequence str)`
`static long`	`findUTFLength(CharSequence str, long strlen)`
`static long`	`findUTFLength(String str)`
`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()`
`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`	`parseUTF(StopCharTester tester)`
`void`	`parseUTF(StringBuilder builder, StopCharTester tester)` Populate a StringBuilder with the UTF encoded text until the end.
`int`	`read()` Reads a byte of data.
`int`	`read(byte[] bytes)` Reads into an array of bytes.
`abstract int`	`read(byte[] bytes, 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.
`int`	`readByteOrThrow(boolean selfTerminating)`
`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.
`<E> E`	`readEnum(Class<E> eClass)` Read a String with `readUTFΔ` which is converted to an enumerable type.
`void`	`readFully(byte[] bytes)` Reads some bytes from an input stream and stores them into the buffer array `b`.
`void`	`readFully(char[] data)`
`<T> T`	`readInstance(Class<T> objClass, T obj)` Read an instance of a class assuming objClass was provided when written.
`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.
`<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.
`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.
`static void`	`readUTF0(Bytes bytes, Appendable appendable, int utflen)`
`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`	`refCount()`
`boolean`	`release()`
`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 selfTerminating)` If set to true, the end of the Bytes will be the end of any consuming String, double or long.
`protected void`	`setObjectSerializer(ObjectSerializer objectSerializer)`
`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
`ByteBuffer`	`sliceAsByteBuffer(ByteBuffer toReuse)` Returns a `ByteBuffer` whose content is a shared subsequence of this bytes' content.
`boolean`	`startsWith(RandomDataInput input)`
`boolean`	`stepBackAndSkipTo(StopCharTester tester)` Make sure we just read a stop character
`int`	`threadIdForLockInt(long offset)` Lock which uses 4 bytes.
`long`	`threadIdForLockLong(long offset)` Lock which uses 8 bytes.
`String`	`toDebugString()`
`String`	`toDebugString(long limit)`
`static String`	`toHex(Bytes buffer)` display the hex data of `Bytes` from the position() to the limit()
`String`	`toString()`
`void`	`toString(Appendable sb, long start, long position, long end)` Write a portion of the Bytes to an Appendable for printing.
`static String`	`toString(Bytes buffer)` display the buffer as a string
`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[] bytes)` Writes to the output stream all the bytes in array `bytes`.
`void`	`write(byte[] bytes, 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(long offset, byte[] bytes)` Writes to the output stream all the bytes in array `bytes`.
`void`	`write(long offset, byte[] bytes, int off, int len)`
`void`	`write(long offset, Bytes bytes)`
`void`	`write(RandomDataInput bytes)` Copies the contents of a RandomDataInput from the position to the limit.
`void`	`write(RandomDataInput bytes, 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`	`writeBytes(String s)` Writes a string 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);
`<E> void`	`writeEnum(E e)` Write the object in a form which can be uniquely recreated by readEnum.
`<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`	`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).
`<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 obj)` Write an object as either an "enumerable object" or a Serializable/Externalizable object using Java Serialization.
`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`	`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 str)` Writes two bytes of length information to the output stream, followed by the modified UTF-8 representation of every character in the string `s`.
`static void`	`writeUTF0(Bytes bytes, CharSequence str, long strlen)`
`void`	`writeUTFΔ(CharSequence str)` 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.

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

Methods inherited from interface net.openhft.lang.io.RandomDataInput
readByte, readByte, readChar, readChar, readDouble, readDouble, readFloat, readFloat, readFully, readFully, readFully, readInt, readInt, readLong, readLong, readObject, readShort, readShort, readVolatileInt, readVolatileInt, readVolatileLong, readVolatileLong

Methods inherited from interface net.openhft.lang.io.RandomDataOutput
compareAndSwapInt, compareAndSwapLong, write, writeByte, writeChar, writeChar, writeDouble, writeDouble, writeFloat, writeFloat, writeInt, writeInt, writeLong, writeLong, writeObject, writeOrderedInt, writeOrderedInt, writeOrderedLong, writeOrderedLong, writeShort, writeShort, zeroOut, zeroOut, zeroOut

Methods inherited from interface net.openhft.lang.io.BytesStore
address, bytes, bytes

Methods inherited from interface net.openhft.lang.io.BytesCommon
alignPositionAddr, byteOrder, capacity, checkEndOfBuffer, limit, limit, load, position, position, remaining, slice, slice

Methods inherited from interface java.lang.CharSequence
subSequence

- Field Detail
  - END_OF_BUFFER
```
public static final int END_OF_BUFFER
```
    See Also:
    Constant Field Values
  - UNSIGNED_INT_MASK
```
public static final long UNSIGNED_INT_MASK
```
    See Also:
    Constant Field Values
  - SLEEP_THRESHOLD
```
public static final int SLEEP_THRESHOLD
```
    See Also:
    Constant Field Values
  - finished
```
protected boolean finished
```
- Method Detail
  - setObjectSerializer
```
protected void setObjectSerializer(ObjectSerializer objectSerializer)
```
  - clearThreadAssociation
```
public void clearThreadAssociation()
```
    clearing the volatile singleThread is a write barrier.
    
    Specified by:
    
    clearThreadAssociation in interface Bytes
  - readUTF0
```
public static void readUTF0(Bytes bytes,
            @NotNull
            Appendable appendable,
            int utflen)
                     throws IOException
```
    Throws:
    
    IOException
  - findUTFLength
```
public static long findUTFLength(@NotNull
                 CharSequence str)
```
  - findUTFLength
```
public static long findUTFLength(@NotNull
                 CharSequence str,
                 long strlen)
```
  - findUTFLength
```
public static long findUTFLength(@NotNull
                 String str)
```
  - writeUTF0
```
public static void writeUTF0(Bytes bytes,
             @NotNull
             CharSequence str,
             long strlen)
```
  - read8bitText
```
public boolean read8bitText(@NotNull
                   StringBuilder stringBuilder)
                     throws StreamCorruptedException
```
    Specified by:
    
    read8bitText in interface RandomDataInput
    
    Throws:
    
    StreamCorruptedException
  - write8bitText
```
public void write8bitText(@Nullable
                 CharSequence s)
```
    Specified by:
    
    write8bitText in interface RandomDataOutput
  - toHex
```
public static String toHex(@NotNull
           Bytes buffer)
```
    display the hex data of Bytes from the position() to the limit()
    
    Parameters:
    buffer - the buffer you wish to toString()
    
    Returns:
    hex representation of the buffer, from example [0D ,OA, FF]
  - toString
```
public static String toString(@NotNull
              Bytes buffer)
```
    display the buffer as a string
    
    Parameters:
    buffer - the buffer you wish to toString()
    
    Returns:
    hex representation of the buffer, from example [0D ,OA, FF]
  - size
```
public long size()
```
    Specified by:
    
    size in interface BytesStore
  - free
```
public void free()
```
    Specified by:
    
    free in interface BytesStore
  - reserve
```
public void reserve()
```
    Specified by:
    
    reserve in interface ReferenceCounted
  - release
```
public boolean release()
```
    Specified by:
    
    release in interface ReferenceCounted
  - cleanup
```
protected abstract void cleanup()
```
  - refCount
```
public int refCount()
```
    Specified by:
    
    refCount in interface ReferenceCounted
  - selfTerminating
```
public void selfTerminating(boolean selfTerminating)
```
    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:
    selfTerminating - if true, the end of the Buffer is silent.
  - selfTerminating
```
public boolean selfTerminating()
```
    Specified by:
    
    selfTerminating in interface ByteStringParser
    
    Returns:
    if this Bytes self terminates.
  - 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.
  - readByteOrThrow
```
public int readByteOrThrow(boolean selfTerminating)
                    throws BufferUnderflowException
```
    Throws:
    
    BufferUnderflowException
  - parseBoolean
```
public Boolean parseBoolean(@NotNull
                   StopCharTester tester)
```
    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.
  - readFully
```
public void readFully(@NotNull
             byte[] bytes)
```
    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:
    bytes - the buffer into which the data is read.
  - readFully
```
public void readFully(@NotNull
             char[] data)
```
    Specified by:
    
    readFully in interface RandomDataInput
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - readLine
```
@NotNull
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.
  - 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
  - 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.
  - 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
  - parseUTF
```
@NotNull
public String parseUTF(@NotNull
                      StopCharTester tester)
```
    Specified by:
    
    parseUTF in interface ByteStringParser
  - parseUTF
```
public void parseUTF(@NotNull
            StringBuilder builder,
            @NotNull
            StopCharTester tester)
```
    Description copied from interface: ByteStringParser
    
    Populate a StringBuilder with the UTF encoded text until the end.
    
    Specified by:
    
    parseUTF in interface ByteStringParser
    
    Parameters:
    builder - to zeroOut and append to.
    tester - to detect when to stop.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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
  - write
```
public void write(@NotNull
         byte[] bytes)
```
    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:
    bytes - the data.
  - 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.
  - 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.
  - 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.
  - 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)
  - 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)
  - writeUTF
```
public void writeUTF(@NotNull
            String str)
```
    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:
    str - the string value to be written. Cannot be null
  - writeUTFΔ
```
public void writeUTFΔ(@Nullable
             CharSequence str)
               throws IllegalArgumentException
```
    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:
    str - the string value to be written. Can be null.
    
    Throws:
    
    IllegalArgumentException - if there is not enough space left
  - 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.
  - append
```
@NotNull
public ByteStringAppender append(@NotNull
                                CharSequence str)
```
    Specified by:
    
    append in interface Appendable
    
    Specified by:
    
    append in interface ByteStringAppender
  - 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.
  - 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.
  - 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.
  - write
```
public void write(long offset,
         @NotNull
         byte[] bytes)
```
    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
    bytes - the data.
  - write
```
public void write(long offset,
         Bytes bytes)
```
    Specified by:
    
    write in interface RandomDataOutput
  - write
```
public void write(byte[] bytes,
         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:
    bytes - the data.
    off - the start offset in the data.
    len - the number of bytes to write.
  - write
```
public void write(long offset,
         byte[] bytes,
         int off,
         int len)
```
    Specified by:
    
    write in interface RandomDataOutput
  - write
```
public void write(@NotNull
         char[] data)
```
    Specified by:
    
    write in interface RandomDataOutput
  - write
```
public void write(@NotNull
         char[] data,
         int off,
         int len)
```
    Specified by:
    
    write in interface RandomDataOutput
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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.
  - 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
  - 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.
  - 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.
  - append
```
@NotNull
public ByteStringAppender append(@NotNull
                                CharSequence s,
                                int start,
                                int end)
```
    Specified by:
    
    append in interface Appendable
    
    Specified by:
    
    append in interface ByteStringAppender
  - append
```
@NotNull
public ByteStringAppender append(@Nullable
                                Enum value)
```
    Specified by:
    
    append in interface ByteStringAppender
  - 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.
  - append
```
@NotNull
public ByteStringAppender append(char c)
```
    Specified by:
    
    append in interface Appendable
    
    Specified by:
    
    append in interface ByteStringAppender
  - append
```
@NotNull
public ByteStringAppender append(int num)
```
    Specified by:
    
    append in interface ByteStringAppender
  - append
```
@NotNull
public ByteStringAppender append(long num)
```
    Specified by:
    
    append in interface ByteStringAppender
  - append
```
@NotNull
public ByteStringAppender append(long num,
                                int base)
```
    Specified by:
    
    append in interface ByteStringAppender
  - appendDateMillis
```
@NotNull
public ByteStringAppender appendDateMillis(long timeInMS)
```
    Specified by:
    
    appendDateMillis in interface ByteStringAppender
  - appendDateTimeMillis
```
@NotNull
public ByteStringAppender appendDateTimeMillis(long timeInMS)
```
    Specified by:
    
    appendDateTimeMillis in interface ByteStringAppender
  - appendTimeMillis
```
@NotNull
public ByteStringAppender appendTimeMillis(long timeInMS)
```
    Specified by:
    
    appendTimeMillis in interface ByteStringAppender
  - append
```
@NotNull
public ByteStringAppender append(double d)
```
    Specified by:
    
    append in interface ByteStringAppender
  - parseDouble
```
public double parseDouble()
```
    Specified by:
    
    parseDouble in interface ByteStringParser
  - compareRest
```
protected boolean compareRest(String s)
```
  - append
```
@NotNull
public <E> ByteStringAppender append(@NotNull
                                    Iterable<E> list,
                                    @NotNull
                                    CharSequence separator)
```
    Specified by:
    
    append in interface ByteStringAppender
  - parseDecimal
```
@NotNull
public MutableDecimal parseDecimal(@NotNull
                                  MutableDecimal decimal)
```
    Specified by:
    
    parseDecimal in interface ByteStringParser
  - parseLong
```
public long parseLong()
```
    Specified by:
    
    parseLong in interface ByteStringParser
    
    Returns:
    the next long, stopping at the first invalid character
  - parseLong
```
public long parseLong(int base)
```
    Specified by:
    
    parseLong in interface ByteStringParser
    
    Parameters:
    base - to use.
    
    Returns:
    the next long, stopping at the first invalid character
  - append
```
@NotNull
public ByteStringAppender append(double d,
                                int precision)
```
    Specified by:
    
    append in interface ByteStringAppender
  - append
```
@NotNull
public ByteStringAppender append(@NotNull
                                MutableDecimal md)
```
    Specified by:
    
    append in interface ByteStringAppender
  - inputStream
```
@NotNull
public InputStream inputStream()
```
    Specified by:
    
    inputStream in interface BytesCommon
    
    Returns:
    these Bytes as an InputStream
  - outputStream
```
@NotNull
public OutputStream outputStream()
```
    Specified by:
    
    outputStream in interface BytesCommon
    
    Returns:
    these Bytes as an OutputStream
  - objectSerializer
```
@NotNull
public ObjectSerializer objectSerializer()
```
    Specified by:
    
    objectSerializer in interface BytesCommon
    
    Specified by:
    
    objectSerializer in interface BytesStore
    
    Returns:
    the factory for marshallers.
  - 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
  - readEnum
```
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.
  - parseEnum
```
public <E extends Enum<E>> E parseEnum(@NotNull
                              Class<E> eClass,
                              @NotNull
                              StopCharTester tester)
```
    Specified by:
    
    parseEnum in interface ByteStringParser
  - 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
  - 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
  - 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
  - readMap
```
@NotNull
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
  - available
```
public int available()
```
    Specified by:
    
    available in interface ObjectInput
    
    Specified by:
    
    available in interface RandomDataInput
    
    Returns:
    remaining() or Integer.MAX_VALUE if larger.
  - read
```
public int read()
```
    Description copied from interface: RandomDataInput
    
    Reads a byte of data. This method will block if no input is available.
    
    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.
  - read
```
public int read(@NotNull
       byte[] bytes)
```
    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:
    bytes - 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.
  - read
```
public abstract int read(@NotNull
       byte[] bytes,
       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:
    bytes - 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.
  - 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.
  - 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
  - finish
```
public void finish()
            throws IndexOutOfBoundsException
```
    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
    
    Throws:
    
    IndexOutOfBoundsException - if too much data was written.
  - isFinished
```
public boolean isFinished()
```
    Specified by:
    
    isFinished in interface BytesCommon
    
    Returns:
    has finish been called.
  - clear
```
public AbstractBytes 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
  - 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
  - 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
  - readObject
```
@Nullable
public Object readObject()
```
    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
  - 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.
  - 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
  - writeObject
```
public void writeObject(@Nullable
               Object obj)
```
    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:
    obj - to write
  - 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
  - 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.
  - 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.
  - 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)
  - 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
  - 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
  - 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.
  - 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.
  - 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.
  - 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)
  - 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
  - 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
  - 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.
  - 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
  - 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
  - addByte
```
public byte addByte(long offset,
           byte b)
```
    Specified by:
    
    addByte in interface RandomDataUpdate
  - addUnsignedByte
```
public int addUnsignedByte(long offset,
                  int i)
```
    Specified by:
    
    addUnsignedByte in interface RandomDataUpdate
  - addShort
```
public short addShort(long offset,
             short s)
```
    Specified by:
    
    addShort in interface RandomDataUpdate
  - addUnsignedShort
```
public int addUnsignedShort(long offset,
                   int i)
```
    Specified by:
    
    addUnsignedShort in interface RandomDataUpdate
  - addInt
```
public int addInt(long offset,
         int i)
```
    Specified by:
    
    addInt in interface RandomDataUpdate
  - addUnsignedInt
```
public long addUnsignedInt(long offset,
                  long i)
```
    Specified by:
    
    addUnsignedInt in interface RandomDataUpdate
  - addLong
```
public long addLong(long offset,
           long i)
```
    Specified by:
    
    addLong in interface RandomDataUpdate
  - addFloat
```
public float addFloat(long offset,
             float f)
```
    Specified by:
    
    addFloat in interface RandomDataUpdate
  - addDouble
```
public double addDouble(long offset,
               double d)
```
    Specified by:
    
    addDouble in interface RandomDataUpdate
  - addAtomicInt
```
public int addAtomicInt(long offset,
               int i)
```
    Specified by:
    
    addAtomicInt in interface RandomDataUpdate
  - addAtomicLong
```
public long addAtomicLong(long offset,
                 long delta)
```
    Specified by:
    
    addAtomicLong in interface RandomDataUpdate
  - addAtomicFloat
```
public float addAtomicFloat(long offset,
                   float delta)
```
    Specified by:
    
    addAtomicFloat in interface RandomDataUpdate
  - addAtomicDouble
```
public double addAtomicDouble(long offset,
                     double delta)
```
    Specified by:
    
    addAtomicDouble in interface RandomDataUpdate
  - 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.
  - 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.
  - 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
  - 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
  - length
```
public int length()
```
    Specified by:
    
    length in interface CharSequence
  - charAt
```
public char charAt(int index)
```
    Specified by:
    
    charAt in interface CharSequence
  - 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.
  - 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
  - write
```
public void write(RandomDataInput bytes)
```
    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:
    bytes - to copy
  - write
```
public void write(RandomDataInput bytes,
         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:
    bytes - to copy
    position - to copy from
    length - to copy
  - write
```
public void write(@NotNull
         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
  - startsWith
```
public boolean startsWith(RandomDataInput input)
```
    Specified by:
    
    startsWith in interface RandomDataInput
  - compare
```
public boolean compare(long offset,
              RandomDataInput input,
              long inputOffset,
              long len)
```
    Specified by:
    
    compare in interface RandomDataInput
  - toString
```
@NotNull
public String toString()
```
    Specified by:
    
    toString in interface CharSequence
    
    Overrides:
    
    toString in class Object
  - toDebugString
```
@NotNull
public String toDebugString()
```
    Specified by:
    
    toDebugString in interface BytesCommon
  - toDebugString
```
@NotNull
public String toDebugString(long limit)
```
    Specified by:
    
    toDebugString in interface BytesCommon
  - 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.
  - 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()
  - 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
  - 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.
  - compareAndSwapDouble
```
public boolean compareAndSwapDouble(long offset,
                           double expected,
                           double value)
```
    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
    value - 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
  - 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
  - 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
  - unlockRWReadLock
```
public void unlockRWReadLock(long offset)
```
    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
  - unlockRWWriteLock
```
public void unlockRWWriteLock(long offset)
```
    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

Class AbstractBytes

Field Summary

Method Summary

Methods inherited from class java.lang.Object

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

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

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

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

Methods inherited from interface java.lang.CharSequence

Field Detail

END_OF_BUFFER

UNSIGNED_INT_MASK

SLEEP_THRESHOLD

finished

Method Detail

setObjectSerializer

clearThreadAssociation

readUTF0

findUTFLength

findUTFLength

findUTFLength

writeUTF0

read8bitText

write8bitText

toHex

toString

size

free

reserve

release

cleanup

refCount

selfTerminating

selfTerminating

readUnsignedByteOrThrow

readByteOrThrow

parseBoolean

readFully

readFully

skipBytes

readBoolean

readBoolean

readUnsignedByte

readUnsignedByte

readUnsignedShort

readUnsignedShort

readLine

readUTFΔ

readUTFΔ

readUTFΔ

parseUTF

parseUTF

stepBackAndSkipTo

skipTo

readUTF

readCompactShort

readCompactUnsignedShort

readInt24

readInt24

readUnsignedInt

readUnsignedInt

readCompactInt

readCompactUnsignedInt

readInt48

readInt48

readCompactLong

readStopBit

readCompactDouble

read

read

write

writeBoolean

writeBoolean

writeBytes

writeChars

writeChars

writeUTF

writeUTFΔ

writeUTFΔ

append