Computes (a + b) mod capacity, for (a+b) >= 0

Counts the space between two positions: (begin + end) mod capacity

Creates a new BiBuffer made of this buffer plus the other buffer, in this order.

Implements read without necessarily checking for available space.

Implements read without necessarily checking for available space.

Implements read without necessarily checking for available space.

Implements read without necessarily checking for available data.

Implements write without necessarily checking for available space.

Implements write without necessarily checking for available space.

Implements write without necessarily checking for available space.

Implements write without necessarily checking for available space.

Implements write without necessarily checking for available space.

Advances the read position by n bytes, as if n bytes had been read into some destination.

The buffer's capacity.

Checks if at least n bytes can be written

Checks if at least n bytes can be written

Checks if at least n bytes can be written

Makes the buffer empty. After a call to clear, isReadable returns false, readableBytes returns zero and writableBytes returns the buffer's capacity. The buffer's capacity is not modified.

Returns a new buffer that shares its content with this buffer, but has independent read and write positions. Initially the positions are the same but they evolve differently.

Checks if the buffer is empty, that is, if readableBytes == 0.

True if this output is closed or has definitively reached its end. If isEnded == true then isWriteable == false and writableBytes == 0.

Checks if the buffer is full, that is, if writableBytes == 0.

* Checks if a byte can be read from this NiolInput.

* True if a byte can be written to this NiolOutput.

Reads a byte

Fills the given NiolBuffer. Throws an exception if there isn't enough data available.

Fills the given ByteBuffer. Throws an exception if there isn't enough data available.

Reads a boolean.

Reads one byte and returns false if it's equal to the given value, true otherwise.

Reads one byte and returns true if it's equal to the given value, false otherwise.

Reads a boolean

Reads a byte

Reads the next length bytes and put them into dst at the given offset. Throws an exception if there isn't enough data available.

Reads the next dst.length bytes and put them into dst. Throws an exception if there isn't enough data to fill the array.

Reads the next n bytes. Throws an Exception if there isn't enough data available.

Reads a big-endian char

Reads a little-endian char

Reads the next bytesLength bytes as a CharSequence encoded with the given charset.

Reads a big-endian 8-bytes double

Reads a little-endian 8-bytes double

Reads the next length doubles and put them into dst at the given offset. Uses big-endian for each value. Throws an exception if there isn't enough data available.

Reads the next dst.length doubles and put them into dst. Uses big-endian for each value. Throws an exception if there isn't enough data to fill the array.

Reads the next n doubles. Uses big-endian for each value. Throws an Exception if there isn't enough data available.

Reads the next length doubles and put them into dst at the given offset. Uses little-endian for each value. Throws an exception if there isn't enough data available.

Reads the next dst.length doubles and put them into dst. Uses little-endian for each value. Throws an exception if there isn't enough data to fill the array.

Reads the next n doubles. Uses little-endian for each value. Throws an Exception if there isn't enough data available.

Reads a big-endian 4-bytes float

Reads a little-endian 4-bytes float

Reads the next length floats and put them into dst at the given offset. Uses big-endian for each value. Throws an exception if there isn't enough data available.

Reads the next dst.length floats and put them into dst. Uses big-endian for each value. Throws an exception if there isn't enough data to fill the array.

Reads the next n floats. Uses big-endian for each value. Throws an Exception if there isn't enough data available.

Reads the next length floats and put them into dst at the given offset. Uses little-endian for each value. Throws an exception if there isn't enough data available.

Reads the next dst.length floats and put them into dst. Uses little-endian for each value. Throws an exception if there isn't enough data to fill the array.

Reads the next n floats. Uses little-endian for each value. Throws an Exception if there isn't enough data available.

Reads a big-endian 4-bytes integer

Reads a little-endian 4-bytes integer

Reads the next length ints and put them into dst at the given offset. Uses big-endian for each value. Throws an exception if there isn't enough data available.

Reads the next dst.length ints and put them into dst. Uses big-endian for each value. Throws an exception if there isn't enough data to fill the array.

Reads the next n ints. Uses big-endian for each value. Throws an Exception if there isn't enough data available.

Reads the next length ints and put them into dst at the given offset. Uses little-endian for each value. Throws an exception if there isn't enough data available.

Reads the next dst.length ints and put them into dst. Uses little-endian for each value. Throws an exception if there isn't enough data to fill the array.

Reads the next n ints. Uses little-endian for each value. Throws an Exception if there isn't enough data available.

Reads a big-endian 8-bytes integer

Reads a little-endian 8-bytes integer

Reads the next length longs and put them into dst at the given offset. Uses big-endian for each value. Throws an exception if there isn't enough data available.

Reads the next dst.length longs and put them into dst. Uses big-endian for each value. Throws an exception if there isn't enough data to fill the array.

Reads the next n longs. Uses big-endian for each value. Throws an Exception if there isn't enough data available.

Reads the next length longs and put them into dst at the given offset. Uses little-endian for each value. Throws an exception if there isn't enough data available.

Reads the next dst.length longs and put them into dst. Uses little-endian for each value. Throws an exception if there isn't enough data to fill the array.

Reads the next n longs. Uses little-endian for each value. Throws an Exception if there isn't enough data available.

Reads a big-endian 3-bytes integer

Reads a little-endian 3-bytes integer

Reads a variable-length int using the signed/zig-zag encoding.

Reads a variable-length long using the signed/zig-zag encoding.

Reads a big-endian short

Reads a big-endian unsigned short to determine the sequence's length, then reads it.

Reads a little-endian unsigned short to determine the sequence's length, then reads it.

Reads a little-endian short

Reads a big-endian unsigned short to determine the string's length, then reads it.

Reads a little-endian unsigned short to determine the string's length, then reads it.

Reads the next length shorts and put them into dst at the given offset. Uses big-endian for each value. Throws an exception if there isn't enough data available.

Reads the next dst.length shorts and put them into dst. Uses big-endian for each value. Throws an exception if there isn't enough data to fill the array.

Reads the next n shorts. Uses big-endian for each value. Throws an Exception if there isn't enough data available.

Reads the next length shorts and put them into dst at the given offset. Uses little-endian for each value. Throws an exception if there isn't enough data available.

Reads the next dst.length shorts and put them into dst. Uses little-endian for each value. Throws an exception if there isn't enough data to fill the array.

Reads the next n shorts. Uses little-endian for each value. Throws an Exception if there isn't enough data available.

Reads at most dst.writableBytes bytes into dst. The buffer's position will be advanced by the number of bytes read from this NiolInput.

Reads some bytes and writes them to dst. Returns the actual number of bytes read, possibly zero.

Reads some bytes and writes them to dst. Returns the actual number of bytes read, possibly zero.

Reads at most dst.remaining() bytes into dst. The buffer's position will be advanced by the number of bytes read from this NiolInput.

Reads at most length bytes and put them into dst at the given offset. Returns the actual number of bytes read, possibly zero.

Reads at most dst.length bytes into dst. Returns the actual number of bytes read, possibly zero.

Reads the next bytesLength bytes as a String encoded with the given charset.

Reads a big-endian 16-bytes UUID

Reads an unsigned byte as an int

Reads a big-endian unsigned int as a long

Reads a little-endian unsigned int as a long

Reads a big-endian unsigned medium as an int

Reads a little-endian unsigned medium as an int

Reads a big-endian unsigned short as an int

Reads a little-endian unsigned short as an int

Reads a VarInt to determine the sequence's length, then reads the CharSequence.

Reads a variable-length int using the normal/unsigned encoding.

Reads a variable-length long using the normal/unsigned encoding.

Reads a VarInt to determine the string's length, then reads the string.

The number of bytes that can be read from this buffer. This number is always >= 0. If readableBytes == 0 then no byte can be read and isReadable == false.

Creates a "slice" that gives a limited access to the next length readable bytes. No copy is involved. Throws an exception if readableBytes < length. The returned buffer satisfies readableBytes == length.

Reads all the readable bytes of this buffer into a new byte array.

Attempts to read a byte. If the input is empty, returns -1. Otherwise, returns the byte value as an int in the range 0-255.

Attempts to write a byte. Returns false if the output is full.

The number of bytes that can be written to this NiolOutput. This number is always >= 0. It may be underestimated except when it's zero, that is, if writableBytes == 0 then no byte can be written and isWritable == false.

Creates a "slice" that gives a limited access to the next length writable bytes. No copy is involved. Throws an exception if writableBytes < length. The returned buffer satisfies writableBytes == length.

Writes all of the given NiolBuffer. Throws an exception if there isn't enough space for the data.

Writes the content of src, starting at index offset and ending at index offset+length-1. Throws an exception if there isn't enough space for the data or if the array index goes out of bounds.

Writes all the bytes of src. Throws an exception if there isn't enough space for the data.

Writes all of the given ByteBuffer. Throws an exception if there isn't enough space for the data.

Writes a byte.

Writes a boolean. If it's true, writes trueValue. If it's false, writes falseValue.

Writes a boolean. The default behavior is as follow: If it's true, writes the byte 1. If it's false, writes the byte 0.

Writes a boolean. The default behavior is as follow: If the value is true, writes the byte 1. If it's false, writes the byte 0.

Writes the content of src, starting at index offset and ending at index offset+length-1. Throws an exception if there isn't enough space for the data or if the array index goes out of bounds.

Writes all the booleans of src. Throws an exception if there isn't enough space for the data.

Writes the least significant byte of a long.

Writes the least significant byte of an int.

Writes a byte.

Writes a big-endian char.

Writes a little-endian char.

Writes a CharSequence with the given charset. The written data isn't prefixed by its length.

Writes a big-endian 8-bytes double.

Writes a little-endian 8-bytes double.

Writes the content of src, starting at index offset and ending at index offset+length-1. Uses big-endian for each value. Throws an exception if there isn't enough space for the data or if the array index goes out of bounds.

Writes all the doubles of src. Uses big-endian for each value. Throws an exception if there isn't enough space for the data.

Writes the content of src, starting at index offset and ending at index offset+length-1. Uses little-endian for each value. Throws an exception if there isn't enough space for the data or if the array index goes out of bounds.

Writes all the doubles of src. Uses little-endian for each value. Throws an exception if there isn't enough space for the data.

Writes a big-endian 4-bytes float.

Writes a big-endian 4-bytes float.

Writes a little-endian 4-bytes float.

Writes a little-endian 4-bytes float.

Writes the content of src, starting at index offset and ending at index offset+length-1. Uses big-endian for each value. Throws an exception if there isn't enough space for the data or if the array index goes out of bounds.

Writes all the floats of src. Uses big-endian for each value. Throws an exception if there isn't enough space for the data.

Writes the content of src, starting at index offset and ending at index offset+length-1. Uses little-endian for each value. Throws an exception if there isn't enough space for the data or if the array index goes out of bounds.

Writes all the floats of src. Uses little-endian for each value. Throws an exception if there isn't enough space for the data.

Writes a big-endian 4-bytes integer.

Writes a little-endian 4-bytes integer.

Writes the content of src, starting at index offset and ending at index offset+length-1. Uses big-endian for each value. Throws an exception if there isn't enough space for the data or if the array index goes out of bounds.

Writes all the ints of src. Uses big-endian for each value. Throws an exception if there isn't enough space for the data.

Writes the content of src, starting at index offset and ending at index offset+length-1. Uses little-endian for each value. Throws an exception if there isn't enough space for the data or if the array index goes out of bounds.

Writes all the ints of src. Uses little-endian for each value. Throws an exception if there isn't enough space for the data.

Writes a big-endian 8-bytes integer.

Writes a little-endian 8-bytes integer.

Writes the content of src, starting at index offset and ending at index offset+length-1. Uses big-endian for each value. Throws an exception if there isn't enough space for the data or if the array index goes out of bounds.

Writes all the longs of src. Uses big-endian for each value. Throws an exception if there isn't enough space for the data.

Writes the content of src, starting at index offset and ending at index offset+length-1. Uses little-endian for each value. Throws an exception if there isn't enough space for the data or if the array index goes out of bounds.

Writes all the longs of src. Uses little-endian for each value. Throws an exception if there isn't enough space for the data.

Writes a big-endian 3-bytes integer.

Writes a little-endian 3-bytes integer.

Writes a variable-length int using the signed/zig-zag encoding.

Writes a variable-length long using the signed/zig-zag encoding.

Writes a big-endian short.

Writes a big-endian short.

Writes a little-endian short.

Writes a little-endian short.

Writes a CharSequence with the given charset, prefixed by its length written as a big-endian 2-bytes unsigned integer.

Writes a CharSequence with the given charset, prefixed by its length written as a little-endian 2-bytes unsigned integer.

Writes the content of src, starting at index offset and ending at index offset+length-1. Uses big-endian for each value. Throws an exception if there isn't enough space for the data or if the array index goes out of bounds.

Writes all the shorts of src. Uses big-endian for each value. Throws an exception if there isn't enough space for the data.

Writes the content of src, starting at index offset and ending at index offset+length-1. Uses little-endian for each value. Throws an exception if there isn't enough space for the data or if the array index goes out of bounds.

Writes all the shorts of src. Uses little-endian for each value. Throws an exception if there isn't enough space for the data.

Writes at most src.readableBytes bytes from src into this output. The buffer's read position will be advanced by the number of bytes written to this NiolOutput.

Writes some bytes from src. Returns the actual number of bytes written, possibly zero.

Writes at most maxBytes bytes from src. Returns the actual number of bytes written, possibly zero.

Writes at most src.remaining() bytes from src into this output. The buffer's position will be advanced by the number of bytes written to this NiolOutput.

Writes at most length bytes of src, starting at index offset. Returns the actual number of bytes written, possibly zero.

Writes at most src.length bytes of src. Returns the actual number of bytes written, possibly zero.

Writes at most length booleans of src, starting at index offset. Returns the actual number of booleans written, possibly zero.

Writes at most src.length booleans of src. Returns the actual number of booleans written, possibly zero.

Writes at most length doubles of src, starting at index offset. Uses big-endian for each value. Returns the actual number of doubles written, possibly zero.

Writes at most src.length doubles of src. Uses big-endian for each value. Returns the actual number of doubles written, possibly zero.

Writes at most length doubles of src, starting at index offset. Uses little-endian for each value. Returns the actual number of doubles written, possibly zero.

Writes at most src.length doubles of src for each value. Uses little-endian for each value. Returns the actual number of doubles written, possibly zero.

Writes at most length floats of src, starting at index offset. Uses big-endian for each value. Returns the actual number of floats written, possibly zero.

Writes at most src.length floats of src. Uses big-endian for each value. Returns the actual number of floats written, possibly zero.

Writes at most length floats of src, starting at index offset. Uses little-endian for each value. Returns the actual number of floats written, possibly zero.

Writes at most src.length floats of src for each value. Uses little-endian for each value. Returns the actual number of floats written, possibly zero.

Writes at most length ints of src, starting at index offset. Uses big-endian for each value. Returns the actual number of ints written, possibly zero.

Writes at most src.length ints of src. Uses big-endian for each value. Returns the actual number of ints written, possibly zero.

Writes at most length ints of src, starting at index offset. Uses little-endian for each value. Returns the actual number of ints written, possibly zero.

Writes at most src.length ints of src for each value. Uses little-endian for each value. Returns the actual number of ints written, possibly zero.

Writes at most length longs of src, starting at index offset. Uses big-endian for each value. Returns the actual number of longs written, possibly zero.

Writes at most src.length longs of src. Uses big-endian for each value. Returns the actual number of longs written, possibly zero.

Writes at most length longs of src, starting at index offset. Uses little-endian for each value. Returns the actual number of longs written, possibly zero.

Writes at most src.length longs of src for each value. Uses little-endian for each value. Returns the actual number of longs written, possibly zero.

Writes at most length shorts of src, starting at index offset. Uses big-endian for each value. Returns the actual number of shorts written, possibly zero.

Writes at most src.length shorts of src. Uses big-endian for each value. Returns the actual number of shorts written, possibly zero.

Writes at most length shorts of src, starting at index offset. Uses little-endian for each value. Returns the actual number of shorts written, possibly zero.

Writes at most src.length shorts of src for each value. Uses little-endian for each value. Returns the actual number of shorts written, possibly zero.

Writes a String with the given charset. The written data isn't prefixed by its length.

Writes a UUID as two 8-bytes big-endian integers, most significant bits first.

Writes a variable-length int using the normal/unsigned encoding.

Writes a variable-length long using the normal/unsigned encoding.

Writes a CharSequence with the given charset, preceded by its length written as a normal VarInt.