abstract class ByteReadPacketBase : AbstractInput
ByteReadPacketBase(head: IoBuffer, remaining: Long, pool: ObjectPool<ChunkBuffer>) ByteReadPacketBase(head: ChunkBuffer, remaining: Long, pool: ObjectPool<ChunkBuffer>) |
var |
|
val endOfInput: Boolean
It is |
|
val
|
|
val |
|
val pool: ObjectPool<ChunkBuffer> |
|
val remaining: Long
Number of bytes available for read |
fun canRead(): Boolean |
|
fun close(): Unit |
|
abstract fun closeSource(): Unit
Should close the underlying bytes source. Could do nothing or throw exceptions. |
|
fun discard(n: Int): Int
Discards at most n bytes fun discard(n: Long): Long |
|
fun discardExact(n: Int): Unit
Discards exactly n bytes or fails with EOFException |
|
fun ensureNextHead(current: ChunkBuffer): ChunkBuffer? |
|
abstract fun fill(destination: Memory, offset: Int, length: Int): Int
Read the next bytes into the destination starting at offset at most length bytes. May block until at least one byte is available. Usually bypass all exceptions from the underlying source. open fun fill(): ChunkBuffer?
Reads the next chunk suitable for reading or |
|
fun fixGapAfterRead(current: ChunkBuffer): Unit |
|
fun hasBytes(n: Int): Boolean |
|
fun markNoMoreChunksAvailable(): Unit |
|
fun peekTo(destination: Memory, destinationOffset: Long, offset: Long, min: Long, max: Long): Long
Copy at least min but up to max bytes to the specified destination buffer from this input
skipping offset bytes. If there are not enough bytes available to provide min bytes then
it fails with an exception.
It is safe to specify fun
Copy available bytes to the specified buffer but keep them available. If the underlying implementation could trigger bytes population from the underlying source and block until any bytes available |
|
fun prepareReadHead(minSize: Int): ChunkBuffer? |
|
fun readByte(): Byte |
|
fun |
|
fun |
|
fun
|
|
fun |
|
fun |
|
fun |
|
fun readText(out: Appendable, min: Int = 0, max: Int = Int.MAX_VALUE): Int
Read at least min and at most max characters and append them to out fun readText(min: Int = 0, max: Int = Int.MAX_VALUE): String
|
|
fun readTextExact(out: Appendable, exactCharacters: Int): Unit
Read exactly exactCharacters characters and append them to out fun readTextExact(exactCharacters: Int): String
Read a string exactly exactCharacters length |
|
fun release(): Unit
Release packet. After this function invocation the packet becomes empty. If it has been copied via ByteReadPacket.copy then the copy should be released as well. |
|
fun tryPeek(): Int
Returns next byte (unsigned) or |
|
fun |
val |
val Input.
For streaming input it should be Input.endOfInput instead. |
|
val Input.
For streaming input there is no reliable way to detect it without triggering bytes population from the underlying source. Consider using Input.endOfInput or use ByteReadPacket instead. |
fun Input. fun Input.completeReadHead(current: ChunkBuffer): Unit |
|
fun Input.copyTo(output: Output): Long
Copy all bytes to the output. Depending on actual input and output implementation it could be zero-copy or copy byte per byte. All regular types such as ByteReadPacket, BytePacketBuilder, AbstractInput and AbstractOutput are always optimized so no bytes will be copied. |
|
fun Input.discard(): Long
Discard all remaining bytes. |
|
fun Input.discardExact(n: Long): Unit fun Input.discardExact(n: Int): Unit
Discard exactly n bytes or fail if not enough bytes in the input to be discarded. |
|
fun Input.discardUntilDelimiter(delimiter: Byte): Long
Discards bytes until delimiter occurred |
|
fun Input.discardUntilDelimiters(delimiter1: Byte, delimiter2: Byte): Long
Discards bytes until of of the specified delimiters delimiter1 or delimiter2 occurred |
|
fun Input.forEach(block: (Byte) -> Unit): Unit
For every byte from this input invokes block function giving it as parameter. |
|
fun Input.peekCharUtf8(): Char |
|
fun Input. fun Input.
Copy at least min but up to max bytes to the specified destination buffer from this input
skipping offset bytes. If there are not enough bytes available to provide min bytes then
it simply return number of available bytes with no exception so the returned value need
to be checked.
It is safe to specify |
|
fun Input.prepareReadFirstHead(minSize: Int): ChunkBuffer? |
|
fun Input. |
|
fun Input.prepareReadNextHead(current: ChunkBuffer): ChunkBuffer? |
|
fun Input. |
|
fun Input. fun Input.readAvailable(dst: ByteArray, offset: Int = 0, length: Int = dst.size - offset): Int fun Input.readAvailable(dst: ShortArray, offset: Int = 0, length: Int = dst.size - offset): Int fun Input.readAvailable(dst: IntArray, offset: Int = 0, length: Int = dst.size - offset): Int fun Input.readAvailable(dst: LongArray, offset: Int = 0, length: Int = dst.size - offset): Int fun Input.readAvailable(dst: FloatArray, offset: Int = 0, length: Int = dst.size - offset): Int fun Input.readAvailable(dst: DoubleArray, offset: Int = 0, length: Int = dst.size - offset): Int fun Input.readAvailable(dst: Buffer, length: Int = dst.writeRemaining): Int fun Input.readAvailable(destination: Memory, destinationOffset: Int, length: Int): Int fun Input.readAvailable(destination: Memory, destinationOffset: Long, length: Long): Long fun Input.readAvailable(dst: ByteBuffer, length: Int = dst.remaining()): Int |
|
fun Input.readAvailableLittleEndian(dst: <ERROR CLASS>, offset: Int = 0, length: Int = dst.size - offset): Int fun Input.readAvailableLittleEndian(dst: ShortArray, offset: Int = 0, length: Int = dst.size - offset): Int fun Input.readAvailableLittleEndian(dst: IntArray, offset: Int = 0, length: Int = dst.size - offset): Int fun Input.readAvailableLittleEndian(dst: LongArray, offset: Int = 0, length: Int = dst.size - offset): Int fun Input.readAvailableLittleEndian(dst: FloatArray, offset: Int = 0, length: Int = dst.size - offset): Int fun Input.readAvailableLittleEndian(dst: DoubleArray, offset: Int = 0, length: Int = dst.size - offset): Int |
|
fun Input. fun Input. fun Input. fun Input. fun Input. fun Input. |
|
fun Input.readBytes(n: Int): ByteArray
Reads exactly n bytes from the input or fails if not enough bytes available. fun Input.readBytes(): ByteArray
Reads all remaining bytes from the input |
|
fun Input.readBytesOf(min: Int = 0, max: Int = Int.MAX_VALUE): ByteArray
Reads at least min but no more than max bytes from the input to a new byte array |
|
fun ByteReadPacketBase. |
|
fun Input.readDouble(byteOrder: ByteOrder): Double fun Input.readDouble(): Double |
|
fun Input.readDoubleFallback(): Double |
|
fun Input.readDoubleLittleEndian(): Double |
|
fun Input.readFloat(byteOrder: ByteOrder): Float fun Input.readFloat(): Float |
|
fun Input.readFloatFallback(): Float |
|
fun Input.readFloatLittleEndian(): Float |
|
fun Input. fun Input.readFully(dst: ByteArray, offset: Int = 0, length: Int = dst.size - offset): Unit fun Input.readFully(dst: ShortArray, offset: Int = 0, length: Int = dst.size - offset): Unit fun Input.readFully(dst: IntArray, offset: Int = 0, length: Int = dst.size - offset): Unit fun Input.readFully(dst: LongArray, offset: Int = 0, length: Int = dst.size - offset): Unit fun Input.readFully(dst: FloatArray, offset: Int = 0, length: Int = dst.size - offset): Unit fun Input.readFully(dst: DoubleArray, offset: Int = 0, length: Int = dst.size - offset): Unit fun Input.readFully(dst: Buffer, length: Int = dst.writeRemaining): Unit fun Input.readFully(destination: Memory, destinationOffset: Int, length: Int): Unit fun Input.readFully(destination: Memory, destinationOffset: Long, length: Long): Unit fun Input.readFully(dst: <ERROR CLASS>, offset: Int = 0, length: Int = dst.size - offset): Unit fun Input.readFully(dst: ByteBuffer, length: Int = dst.remaining()): Unit |
|
fun Input.readFullyLittleEndian(dst: <ERROR CLASS>, offset: Int = 0, length: Int = dst.size - offset): Unit fun Input.readFullyLittleEndian(dst: ShortArray, offset: Int = 0, length: Int = dst.size - offset): Unit fun Input.readFullyLittleEndian(dst: IntArray, offset: Int = 0, length: Int = dst.size - offset): Unit fun Input.readFullyLittleEndian(dst: LongArray, offset: Int = 0, length: Int = dst.size - offset): Unit fun Input.readFullyLittleEndian(dst: FloatArray, offset: Int = 0, length: Int = dst.size - offset): Unit fun Input.readFullyLittleEndian(dst: DoubleArray, offset: Int = 0, length: Int = dst.size - offset): Unit |
|
fun Input. fun Input. fun Input. fun Input. fun Input. fun Input. |
|
fun Input.readInt(byteOrder: ByteOrder): Int fun Input.readInt(): Int |
|
fun Input.readIntLittleEndian(): Int |
|
fun Input.readLong(byteOrder: ByteOrder): Long fun Input.readLong(): Long |
|
fun Input.readLongLittleEndian(): Long |
|
fun Input.readShort(byteOrder: ByteOrder): Short fun Input.readShort(): Short |
|
fun Input.readShortLittleEndian(): Short |
|
fun Input. fun Input.
Reads at most max characters decoding bytes with specified decoder. Extra character bytes will remain unconsumed fun Input.readText(out: Appendable, charset: Charset = Charsets.UTF_8, max: Int = Int.MAX_VALUE): Int fun Input.readText(charset: Charset = Charsets.UTF_8, max: Int = Int.MAX_VALUE): String
Reads at most max characters decoding bytes with specified charset. Extra character bytes will remain unconsumed |
|
fun Input.
Read exactly n characters interpreting bytes in the specified charset. |
|
fun Input.
Read exactly the specified number of bytes interpreting bytes in the specified charset (optional, UTF-8 by default). fun Input.readTextExactBytes(bytesCount: Int, charset: Charset = Charsets.UTF_8): String
Read exactly bytesCount interpreting bytes in the specified charset (optional, UTF-8 by default). |
|
fun Input.readTextExactCharacters(charactersCount: Int, charset: Charset = Charsets.UTF_8): String
Read exactly charactersCount characters interpreting bytes in the specified charset. |
|
fun Input.readUByte(): <ERROR CLASS> |
|
fun Input.readUInt(): <ERROR CLASS> |
|
fun Input.readULong(): <ERROR CLASS> |
|
fun Input.readUShort(): <ERROR CLASS> |
|
fun Input.readUTF8Line(estimate: Int = 16, limit: Int = Int.MAX_VALUE): String?
Read a string line considering optionally specified estimate but up to optional limit characters length
(does fail once limit exceeded) or return |
|
fun Input.readUTF8LineTo(out: Appendable, limit: Int): Boolean
Read UTF-8 line and append all line characters to out except line endings. Does support CR, LF and CR+LF |
|
fun Input.readUTF8UntilDelimiter(delimiters: String, limit: Int = Int.MAX_VALUE): String
Reads UTF-8 characters until one of the specified delimiters found, limit exceeded or end of stream encountered |
|
fun Input.readUTF8UntilDelimiterTo(out: Appendable, delimiters: String, limit: Int = Int.MAX_VALUE): Int fun Input.readUTF8UntilDelimiterTo(out: Output, delimiters: String, limit: Int = Int.MAX_VALUE): Int
Reads UTF-8 characters to out buffer until one of the specified delimiters found, limit exceeded or end of stream encountered fun Input. |
|
fun Input.readUntilDelimiter(delimiter: Byte, dst: ByteArray, offset: Int = 0, length: Int = dst.size): Int
Copies to dst array at offset at most length bytes or until the specified delimiter occurred. fun Input.readUntilDelimiter(delimiter: Byte, dst: Output): Long
Copies to dst output until the specified delimiter occurred. |
|
fun Input.readUntilDelimiters(delimiter1: Byte, delimiter2: Byte, dst: ByteArray, offset: Int = 0, length: Int = dst.size): Int
Copies to dst array at offset at most length bytes or until one of the specified delimiters delimiter1 or delimiter2 occurred. fun Input.readUntilDelimiters(delimiter1: Byte, delimiter2: Byte, dst: Output): Long
Copies to dst output until one of the specified delimiters delimiter1 or delimiter2 occurred. |
|
fun Input.takeWhile(block: (Buffer) -> Boolean): Unit
Invoke block function for every chunk until end of input or block function return |
|
fun Input.takeWhileSize(initialSize: Int = 1, block: (Buffer) -> Int): Unit
Invoke block function for every chunk until end of input or block function return zero block function returns number of bytes required to read next primitive and shouldn't require too many bytes at once otherwise it could fail with an exception. It is not guaranteed that every chunk will have fixed size but it will be always at least requested bytes length. block function should never release provided buffer and should not write to it otherwise an undefined behaviour could be observed |
abstract class |