ParsableByteArray

const val INVALID_CODE_POINT = 1114112: Int

A value that is outside the valid range of unicode code points.

ParsableByteArray()

Creates a new instance that initially has no backing data.

ParsableByteArray(data: ByteArray!)

Creates a new instance wrapping data, and sets the limit to data.length.

ParsableByteArray(limit: Int)

Creates a new instance with limit bytes and sets the limit.

ParsableByteArray(data: ByteArray!, limit: Int)

Creates a new instance that wraps an existing array.

fun bytesLeft(): Int

Returns the number of bytes yet to be read.

fun capacity(): Int

Returns the capacity of the array, which may be larger than the limit.

fun ensureCapacity(requiredCapacity: Int): Unit

Ensures the backing array is at least requiredCapacity long.

position, limit, and all data in the underlying array (including that beyond limit) are preserved.

This might replace or wipe the underlying array, potentially invalidating any local references.

fun limit(): Int

Returns the limit.

fun peekChar(): Char

Peeks at the next two bytes and interprets them as a big-endian char.

fun peekCodePoint(charset: Charset!): Int

Peeks at the code point starting at getPosition as interpreted by charset.

The exact behaviour depends on charset:

• US_ASCII: Returns the byte at getPosition if it's valid ASCII (less than 0x80), otherwise returns INVALID_CODE_POINT.
• UTF-8: If getPosition is the start of a UTF-8 code unit the whole unit is decoded and returned. Otherwise INVALID_CODE_POINT is returned.
• UTF-16 (all endian-nesses):
  • If getPosition is at the start of a high surrogate code unit and the following two bytes are a isLowSurrogate low surrogate} code unit, the combined code point is returned.
  • Otherwise the single code unit starting at getPosition is returned directly.
  • UTF-16 has no support for byte-level synchronization, so if getPosition is not aligned with the start of a UTF-16 code unit then the result is undefined.

fun peekInt(): Int

Peeks the next four bytes as a signed value.

fun peekUnsignedByte(): Int

Peeks at the next byte as an unsigned value.

fun peekUnsignedInt24(): Int

Peeks the next three bytes as an unsigned value.

fun readBytes(bitArray: ParsableBitArray!, length: Int): Unit

Reads the next length bytes into bitArray, and resets the position of bitArray to zero.

fun readBytes(buffer: ByteBuffer!, length: Int): Unit

Reads the next length bytes into buffer.

fun readBytes(buffer: ByteArray!, offset: Int, length: Int): Unit

Reads the next length bytes into buffer at offset.

fun readDelimiterTerminatedString(delimiter: Char): String?

Reads up to the next delimiter byte (or the limit) as UTF-8 characters.

fun readDouble(): Double

Reads the next eight bytes as a 64-bit floating point value.

fun readFloat(): Float

Reads the next four bytes as a 32-bit floating point value.

fun readInt(): Int

Reads the next four bytes as a signed value

fun readInt24(): Int

Reads the next three bytes as a signed value.

fun readLine(): String?

Reads a line of text in UTF-8.

Equivalent to passing UTF_8 to readLine.

fun readLine(charset: Charset!): String?

Reads a line of text in charset.

A line is considered to be terminated by any one of a carriage return ('\r'), a line feed ('\n'), or a carriage return followed immediately by a line feed ('\r\n'). This method discards leading UTF byte order marks (BOM), if present.

The position is advanced to start of the next line (i.e. any line terminators are skipped).

fun readLittleEndianInt(): Int

Reads the next four bytes as a signed value in little endian order.

fun readLittleEndianInt24(): Int

Reads the next three bytes as a signed value in little endian order.

fun readLittleEndianLong(): Long

Reads the next eight bytes as a signed value in little endian order.

fun readLittleEndianShort(): Short

Reads the next two bytes as a signed value.

fun readLittleEndianUnsignedInt(): Long

Reads the next four bytes as an unsigned value in little endian order.

fun readLittleEndianUnsignedInt24(): Int

Reads the next three bytes as an unsigned value in little endian order.

fun readLittleEndianUnsignedIntToInt(): Int

Reads the next four bytes as a little endian unsigned integer into an integer, if the top bit is a zero.

fun readLittleEndianUnsignedShort(): Int

Reads the next two bytes as an unsigned value.

fun readLong(): Long

Reads the next eight bytes as a signed value.

fun readNullTerminatedString(): String?

Reads up to the next NUL byte (or the limit) as UTF-8 characters.

fun readNullTerminatedString(length: Int): String!

Reads the next length bytes as UTF-8 characters. A terminating NUL byte is discarded, if present.

fun readShort(): Short

Reads the next two bytes as a signed value.

fun readString(length: Int): String!

Reads the next length bytes as UTF-8 characters.

fun readString(length: Int, charset: Charset!): String!

Reads the next length bytes as characters in the specified Charset.

fun readSynchSafeInt(): Int

Reads a Synchsafe integer.

Synchsafe integers keep the highest bit of every byte zeroed. A 32 bit synchsafe integer can store 28 bits of information.

fun readUnsignedByte(): Int

Reads the next byte as an unsigned value.

fun readUnsignedFixedPoint1616(): Int

Reads the next four bytes, returning the integer portion of the fixed point 16.16 integer.

fun readUnsignedInt(): Long

Reads the next four bytes as an unsigned value.

fun readUnsignedInt24(): Int

Reads the next three bytes as an unsigned value.

fun readUnsignedIntToInt(): Int

Reads the next four bytes as an unsigned integer into an integer, if the top bit is a zero.

fun readUnsignedLeb128ToInt(): Int

Reads an unsigned variable-length LEB128 value into an int.

fun readUnsignedLeb128ToLong(): Long

Reads an unsigned variable-length LEB128 value into a long.

fun readUnsignedLongToLong(): Long

Reads the next eight bytes as an unsigned long into a long, if the top bit is a zero.

fun readUnsignedShort(): Int

Reads the next two bytes as an unsigned value.

fun readUtf8EncodedLong(): Long

Reads a long value encoded by UTF-8 encoding

fun readUtfCharsetFromBom(): Charset?

Reads a UTF byte order mark (BOM) and returns the UTF Charset it represents. Returns null without advancing position if no BOM is found.

fun reset(data: ByteArray!): Unit

Updates the instance to wrap data, and resets the position to zero and the limit to data.length.

fun reset(limit: Int): Unit

Resets the position to zero and the limit to the specified value. This might replace or wipe the underlying array, potentially invalidating any local references.

fun reset(data: ByteArray!, limit: Int): Unit

Updates the instance to wrap data, and resets the position to zero.

fun setLimit(limit: Int): Unit

Sets the limit.

@VisibleForTesting
java-static fun setShouldEnforceLimitOnLegacyMethods(enforceLimit: Boolean): Unit

Sets whether all read/peek methods should enforce that getPosition never exceeds limit.

Setting this to true in tests can help catch cases of accidentally reading beyond limit but still within the bounds of the underlying getData.

Some (newer) methods will always enforce the invariant, even when this is set to false.

Defaults to false (this may change in a later release).

fun skipBytes(bytes: Int): Unit

Moves the reading offset by bytes.

fun skipLeb128(): Unit

Skips a variable-length LEB128 value.