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

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

All Implemented Interfaces:

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

Direct Known Subclasses:

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

peter.lawrey

Field Summary

Fields
Modifier and Type	Field and Description
`static long`	`BUSY_LOCK_LIMIT`
`static int`	`INT_LOCK_MASK`
`static int`	`UNSIGNED_BYTE_MASK`
`static long`	`UNSIGNED_INT_MASK`
`static int`	`UNSIGNED_SHORT_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)`
`<E> ByteStringAppender`	`append(List<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)`
`int`	`available()`
`void`	`busyLockInt(long offset)` Lock which uses 4 bytes.
`void`	`busyLockLong(long offset)` Lock across processes Lock which uses 8 bytes.
`BytesMarshallerFactory`	`bytesMarshallerFactory()`
`char`	`charAt(int index)`
`void`	`close()` Finishes the excerpt entry if not finished()
`Thread`	`currentThread()`
`void`	`finish()` Mark the end of the message if writing and check we are at the end of the message if reading.
`void`	`flush()` Check the end of the stream has not overflowed.
`int`	`getAndAdd(long offset, int delta)` Atomically adds the given value to the current value.
`InputStream`	`inputStream()`
`boolean`	`isFinished()`
`int`	`length()`
`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.
`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.
`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`.
`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 clear()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 clear()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`.
`long`	`readUnsignedInt()` Reads four input bytes and returns an `int` value.
`long`	`readUnsignedInt(long offset)` Reads four input bytes and returns an `int` value.
`int`	`readUnsignedShort()` Reads two input bytes and returns an `int` value in the range `0` through `65535`.
`int`	`readUnsignedShort(long offset)` Reads two input bytes and returns an `int` value in the range `0` through `65535`.
`String`	`readUTF()` Reads in a string that has been encoded using a modified UTF-8 format.
`String`	`readUTFΔ()` The same as readUTF() except the length is stop bit encoded.
`String`	`readUTFΔ(long offset)` The same as readUTFΔ() except an offset and maximum length 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.
`void`	`reset()` Start again, unfinished, position() == 0
`void`	`setCurrentThread()`
`int`	`shortThreadId()`
`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
`boolean`	`stepBackAndSkipTo(StopCharTester tester)` Make sure we just read a stop character
`CharSequence`	`subSequence(int start, int end)`
`boolean`	`tryLockInt(long offset)` Lock which uses 4 bytes.
`boolean`	`tryLockLong(long offset)` Lock across processes Lock which uses 8 bytes.
`boolean`	`tryLockNanosInt(long offset, long nanos)` Lock which uses 4 bytes.
`boolean`	`tryLockNanosLong(long offset, long nanos)` Lock across processes Lock which uses 8 bytes.
`long`	`uniqueTid()`
`void`	`unlockInt(long offset)` Lock which uses 4 bytes.
`void`	`unlockLong(long offset)` Lock across processes Lock which uses 8 bytes.
`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(ByteBuffer bb)` Copies the contents of a ByteBuffer from the potision ot the limit.
`void`	`write(BytesCommon bytes, long position, long length)` Copy from one Bytes to another, moves the position by length
`void`	`write(long offset, byte[] bytes)` Writes to the output stream all the bytes in array `bytes`.
`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(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) 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`.
`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) 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`.
`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) 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`.
`void`	`writeCompactUnsignedInt(long v)` 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`.
`void`	`writeCompactUnsignedShort(int v)` 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`.
`<E> void`	`writeEnum(E e)` Write the object in a form which can be uniquely recreated by readEnum.
`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`	`writeStartToPosition(Bytes bb)` Deprecated.
`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`.
`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
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface net.openhft.lang.io.RandomDataInput
readByte, readByte, readChar, readChar, readDouble, readDouble, readFloat, readFloat, 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

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

Methods inherited from interface java.lang.CharSequence
toString

- Field Detail
  - BUSY_LOCK_LIMIT
```
public static final long BUSY_LOCK_LIMIT
```
    See Also:
    Constant Field Values
  - INT_LOCK_MASK
```
public static final int INT_LOCK_MASK
```
    See Also:
    Constant Field Values
  - UNSIGNED_BYTE_MASK
```
public static final int UNSIGNED_BYTE_MASK
```
    See Also:
    Constant Field Values
  - UNSIGNED_SHORT_MASK
```
public static final int UNSIGNED_SHORT_MASK
```
    See Also:
    Constant Field Values
  - UNSIGNED_INT_MASK
```
public static final long UNSIGNED_INT_MASK
```
    See Also:
    Constant Field Values
- Method Detail
  - 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 b is null, a NullPointerException is thrown. If b.length is zero, then no bytes are read. Otherwise, the first byte read is stored into element b[0], the next one into b[1], and so on. If an exception is thrown from this method, then it may be that some but not all bytes of b 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.
  - 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 and maximum length 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
    
    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 clear 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
  - 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.
  - 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)
```
    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.
  - 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(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.
  - 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
  - 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 potision ot the limit. Specified by: write in interface RandomDataOutput Parameters: bb - to copy. writeStartToPosition @Deprecated public void writeStartToPosition(@NotNull Bytes bb) Deprecated. Description copied from interface: RandomDataOutput Copy from one Bytes to another. Copied from the start to the current position. Specified by: writeStartToPosition in interface RandomDataOutput Parameters: bb - to copy from 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 append @NotNull public <E> ByteStringAppender append(@NotNull Iterable<E> list, @NotNull CharSequence separator) Specified by: append in interface ByteStringAppender append @NotNull public <E> ByteStringAppender append(@NotNull List<E> list, @NotNull CharSequence separator) 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 bytesMarshallerFactory @NotNull public BytesMarshallerFactory bytesMarshallerFactory() Specified by: bytesMarshallerFactory in interface BytesCommon 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 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 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 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 clear()ing it. This is suitable to reading a list written using writeList() in the RandomDataOutput interface Specified by: readList in interface RandomDataInput Parameters: list - to populate 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 clear()ing it. This is suitable to reading a list written using writeMap() in the RandomDataOutput interface Specified by: readMap in interface RandomDataInput Parameters: map - to populate 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. reset public void reset() Description copied from interface: BytesCommon Start again, unfinished, position() == 0 Specified by: reset in interface BytesCommon 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 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. 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 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 shortThreadId public int shortThreadId() setCurrentThread public void setCurrentThread() currentThread public Thread currentThread() 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. uniqueTid public long uniqueTid() 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 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 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 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 subSequence public CharSequence subSequence(int start, int end) Specified by: subSequence 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(BytesCommon bytes, long position, long length) Description copied from interface: BytesCommon Copy from one Bytes to another, moves the position by length Specified by: write in interface BytesCommon Parameters: bytes - to copy position - to copy from length - to copy

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.BytesCommon

Methods inherited from interface java.lang.CharSequence

Field Detail

BUSY_LOCK_LIMIT

INT_LOCK_MASK

UNSIGNED_BYTE_MASK

UNSIGNED_SHORT_MASK

UNSIGNED_INT_MASK

Method Detail

parseBoolean

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

write

writeBoolean

writeBoolean

writeBytes

writeChars

writeUTF

writeUTFΔ

writeUTFΔ

append

writeByte

writeUnsignedByte

writeUnsignedByte

write

write

writeUnsignedShort

writeUnsignedShort

writeCompactShort

writeCompactUnsignedShort

writeInt24

writeInt24

writeUnsignedInt

writeUnsignedInt

writeCompactInt

writeCompactUnsignedInt

writeInt48

writeInt48

writeCompactLong

writeStopBit

writeCompactDouble

write

writeStartToPosition

append

append