NiolOutput

trait NiolOutput extends AnyRef

An advanced output.

Linear Supertypes

AnyRef, Any

Known Subclasses

BiBuffer, CircularBuffer, ExpandingOutput, NiolBuffer, JavaDataOutput, ChannelOutput

Ordering

Alphabetic
By Inheritance

Inherited

NiolOutput
AnyRef
Any

Hide All
Show All

Visibility

Public
All

Abstract Value Members

abstract def _write(from: ByteBuffer, len: Int): Unit
Implements write without necessarily checking for available space.
Implements write without necessarily checking for available space.

Attributes
protected[niol]
abstract def _write(from: Array[Byte], off: Int, len: Int): Unit
Implements write without necessarily checking for available space.
Implements write without necessarily checking for available space.

Attributes
protected[niol]
abstract def _write(b: Byte): Unit
Implements write without necessarily checking for available space.
Implements write without necessarily checking for available space.

Attributes
protected[niol]
abstract def isEnded: Boolean
True if this output is closed or has definitively reached its end.
True if this output is closed or has definitively reached its end. If isEnded == true then isWriteable == false and writableBytes == 0.
returns
true if it's closed or has definitively reached its end, false otherwise
abstract def writableBytes: Int
The number of bytes that can be written to this NiolOutput.
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.
returns
n > 0 if can write n bytes, 0 if closed output or full buffer
abstract def write(src: NiolBuffer): Unit
Writes all of the given NiolBuffer.
Writes all of the given NiolBuffer. Throws an exception if there isn't enough space for the data.
src
the buffer to write
abstract def writeSome(src: NiolBuffer): Int
Writes at most src.readableBytes bytes from src into this output.
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.
src
the buffer to write

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def _write(b: Long): Unit
Implements write without necessarily checking for available space.
Implements write without necessarily checking for available space.

Attributes
protected[niol]
final def _write(b: Int): Unit
Implements write without necessarily checking for available space.
Implements write without necessarily checking for available space.

Attributes
protected[niol]
final def asInstanceOf[T0]: T0

Definition Classes
Any
def check(nValues: Int, n: Int): Unit
Checks if at least n bytes can be written
Checks if at least n bytes can be written

Attributes
protected[niol]
def checkWritable(n: Int): Unit
Checks if at least n bytes can be written
Checks if at least n bytes can be written

Attributes
protected[niol]
def clone(): AnyRef

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@native()
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@native()
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isWritable: Boolean
* True if a byte can be written to this NiolOutput.
* True if a byte can be written to this NiolOutput.
returns
true if at least one byte can be written, false otherwise
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@native()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@native()
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def tryWrite(b: Byte): Boolean
Attempts to write a byte.
Attempts to write a byte. Returns false if the output is full.
b
the byte to write
returns
true if the byte has been write, false if the output is full
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... ) @native()
def write(src: Array[Byte], offset: Int, length: Int): Unit
Writes the content of src, starting at index offset and ending at index offset+length-1.
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.
src
the array to write
offset
the first index to use
length
the number of bytes to write
def write(src: Array[Byte]): Unit
Writes all the bytes of src.
Writes all the bytes of src. Throws an exception if there isn't enough space for the data.
src
the array to write
def write(src: ByteBuffer): Unit
Writes all of the given ByteBuffer.
Writes all of the given ByteBuffer. Throws an exception if there isn't enough space for the data.
src
the buffer to write
def write(b: Byte): Unit
Writes a byte.
Writes a byte.
b
the byte to write
def writeBool(bool: Boolean, trueValue: Byte, falseValue: Byte): Unit
Writes a boolean.
Writes a boolean. If it's true, writes trueValue. If it's false, writes falseValue.
bool
the boolean to write
trueValue
the byte to write if the boolean is true
falseValue
the byte to write if the boolean is false
def writeBool(bool: Boolean): Unit
Writes a boolean.
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.
bool
the boolean to write
def writeBoolean(boolean: Boolean): Unit
Writes a boolean.
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.
boolean
the boolean to write
def writeBooleans(src: Array[Boolean], offset: Int, length: Int): Unit
Writes the content of src, starting at index offset and ending at index offset+length-1.
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.
src
the array to write
offset
the first index to use
length
the number of booleans to write
def writeBooleans(src: Array[Boolean]): Unit
Writes all the booleans of src.
Writes all the booleans of src. Throws an exception if there isn't enough space for the data.
src
the array to write
final def writeByte(l: Long): Unit
Writes the least significant byte of a long.
Writes the least significant byte of a long.
l
the value to write
final def writeByte(i: Int): Unit
Writes the least significant byte of an int.
Writes the least significant byte of an int.
i
the value to write
final def writeByte(b: Byte): Unit
Writes a byte.
Writes a byte.
b
the byte to write
final def writeChar(c: Char): Unit
Writes a big-endian char.
Writes a big-endian char.
c
the value to write
final def writeCharLE(c: Char): Unit
Writes a little-endian char.
Writes a little-endian char.
c
the value to write
final def writeCharSequence(csq: CharSequence, charset: Charset = UTF_8): Unit
Writes a CharSequence with the given charset.
Writes a CharSequence with the given charset. The written data isn't prefixed by its length.
csq
the value to write
charset
the charset to encode the CharSequence with
def writeDouble(d: Double): Unit
Writes a big-endian 8-bytes double.
Writes a big-endian 8-bytes double.
d
the value to write
def writeDoubleLE(d: Double): Unit
Writes a little-endian 8-bytes double.
Writes a little-endian 8-bytes double.
d
the value to write
def writeDoubles(src: Array[Double], offset: Int, length: Int): Unit
Writes the content of src, starting at index offset and ending at index offset+length-1.
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.
src
the array to write
offset
the first index to use
length
the number of doubles to write
def writeDoubles(src: Array[Double]): Unit
Writes all the doubles of src.
Writes all the doubles of src. Uses big-endian for each value. Throws an exception if there isn't enough space for the data.
src
the array to write
def writeDoublesLE(src: Array[Double], offset: Int, length: Int): Unit
Writes the content of src, starting at index offset and ending at index offset+length-1.
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.
src
the array to write
offset
the first index to use
length
the number of doubles to write
def writeDoublesLE(src: Array[Double]): Unit
Writes all the doubles of src.
Writes all the doubles of src. Uses little-endian for each value. Throws an exception if there isn't enough space for the data.
src
the array to write
final def writeFloat(f: Double): Unit
Writes a big-endian 4-bytes float.
Writes a big-endian 4-bytes float.
f
the value to write
def writeFloat(f: Float): Unit
Writes a big-endian 4-bytes float.
Writes a big-endian 4-bytes float.
f
the value to write
final def writeFloatLE(f: Double): Unit
Writes a little-endian 4-bytes float.
Writes a little-endian 4-bytes float.
f
the value to write
def writeFloatLE(f: Float): Unit
Writes a little-endian 4-bytes float.
Writes a little-endian 4-bytes float.
f
the value to write
def writeFloats(src: Array[Float], offset: Int, length: Int): Unit
Writes the content of src, starting at index offset and ending at index offset+length-1.
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.
src
the array to write
offset
the first index to use
length
the number of floats to write
def writeFloats(src: Array[Float]): Unit
Writes all the floats of src.
Writes all the floats of src. Uses big-endian for each value. Throws an exception if there isn't enough space for the data.
src
the array to write
def writeFloatsLE(src: Array[Float], offset: Int, length: Int): Unit
Writes the content of src, starting at index offset and ending at index offset+length-1.
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.
src
the array to write
offset
the first index to use
length
the number of floats to write
def writeFloatsLE(src: Array[Float]): Unit
Writes all the floats of src.
Writes all the floats of src. Uses little-endian for each value. Throws an exception if there isn't enough space for the data.
src
the array to write
def writeInt(i: Int): Unit
Writes a big-endian 4-bytes integer.
Writes a big-endian 4-bytes integer.
i
the value to write
def writeIntLE(i: Int): Unit
Writes a little-endian 4-bytes integer.
Writes a little-endian 4-bytes integer.
i
the value to write
def writeInts(src: Array[Int], offset: Int, length: Int): Unit
Writes the content of src, starting at index offset and ending at index offset+length-1.
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.
src
the array to write
offset
the first index to use
length
the number of ints to write
def writeInts(src: Array[Int]): Unit
Writes all the ints of src.
Writes all the ints of src. Uses big-endian for each value. Throws an exception if there isn't enough space for the data.
src
the array to write
def writeIntsLE(src: Array[Int], offset: Int, length: Int): Unit
Writes the content of src, starting at index offset and ending at index offset+length-1.
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.
src
the array to write
offset
the first index to use
length
the number of ints to write
def writeIntsLE(src: Array[Int]): Unit
Writes all the ints of src.
Writes all the ints of src. Uses little-endian for each value. Throws an exception if there isn't enough space for the data.
src
the array to write
def writeLong(l: Long): Unit
Writes a big-endian 8-bytes integer.
Writes a big-endian 8-bytes integer.
l
the value to write
def writeLongLE(l: Long): Unit
Writes a little-endian 8-bytes integer.
Writes a little-endian 8-bytes integer.
l
the value to write
def writeLongs(src: Array[Long], offset: Int, length: Int): Unit
Writes the content of src, starting at index offset and ending at index offset+length-1.
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.
src
the array to write
offset
the first index to use
length
the number of longs to write
def writeLongs(src: Array[Long]): Unit
Writes all the longs of src.
Writes all the longs of src. Uses big-endian for each value. Throws an exception if there isn't enough space for the data.
src
the array to write
def writeLongsLE(src: Array[Long], offset: Int, length: Int): Unit
Writes the content of src, starting at index offset and ending at index offset+length-1.
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.
src
the array to write
offset
the first index to use
length
the number of longs to write
def writeLongsLE(src: Array[Long]): Unit
Writes all the longs of src.
Writes all the longs of src. Uses little-endian for each value. Throws an exception if there isn't enough space for the data.
src
the array to write
def writeMedium(m: Int): Unit
Writes a big-endian 3-bytes integer.
Writes a big-endian 3-bytes integer.
m
the value to write
def writeMediumLE(m: Int): Unit
Writes a little-endian 3-bytes integer.
Writes a little-endian 3-bytes integer.
m
the value to write
final def writeSVarIntZigZag(n: Int): Unit
Writes a variable-length int using the signed/zig-zag encoding.
Writes a variable-length int using the signed/zig-zag encoding.
n
the value to write
final def writeSVarLongZigZag(n: Long): Unit
Writes a variable-length long using the signed/zig-zag encoding.
Writes a variable-length long using the signed/zig-zag encoding.
n
the value to write
def writeShort(i: Int): Unit
Writes a big-endian short.
Writes a big-endian short.
i
the value to write
final def writeShort(s: Short): Unit
Writes a big-endian short.
Writes a big-endian short.
s
the value to write
def writeShortLE(i: Int): Unit
Writes a little-endian short.
Writes a little-endian short.
i
the value to write
final def writeShortLE(s: Short): Unit
Writes a little-endian short.
Writes a little-endian short.
s
the value to write
final def writeShortString(csq: CharSequence, charset: Charset = UTF_8): Unit
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 big-endian 2-bytes unsigned integer.
csq
the value to write
charset
the charset to encode the CharSequence with
final def writeShortStringLE(csq: CharSequence, charset: Charset = UTF_8): Unit
Writes a CharSequence with the given charset, prefixed by its length written as a little-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.
csq
the value to write
charset
the charset to encode the CharSequence with
def writeShorts(src: Array[Short], offset: Int, length: Int): Unit
Writes the content of src, starting at index offset and ending at index offset+length-1.
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.
src
the array to write
offset
the first index to use
length
the number of shorts to write
def writeShorts(src: Array[Short]): Unit
Writes all the shorts of src.
Writes all the shorts of src. Uses big-endian for each value. Throws an exception if there isn't enough space for the data.
src
the array to write
def writeShortsLE(src: Array[Short], offset: Int, length: Int): Unit
Writes the content of src, starting at index offset and ending at index offset+length-1.
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.
src
the array to write
offset
the first index to use
length
the number of shorts to write
def writeShortsLE(src: Array[Short]): Unit
Writes all the shorts of src.
Writes all the shorts of src. Uses little-endian for each value. Throws an exception if there isn't enough space for the data.
src
the array to write
def writeSome(src: Array[Byte], offset: Int, length: Int): Int
Writes at most length bytes of src, starting at index offset.
Writes at most length bytes of src, starting at index offset. Returns the actual number of bytes written, possibly zero.
src
the array to write
offset
the first index to use
length
the number of bytes to write
returns
the number of bytes written
def writeSome(src: Array[Byte]): Int
Writes at most src.length bytes of src.
Writes at most src.length bytes of src. Returns the actual number of bytes written, possibly zero.
src
the array to write
returns
the number of bytes written
def writeSome(src: ByteBuffer): Int
Writes at most src.remaining() bytes from src into this output.
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.
src
the buffer to write
def writeSomeBooleans(src: Array[Boolean], offset: Int, length: Int): Int
Writes at most length booleans of src, starting at index offset.
Writes at most length booleans of src, starting at index offset. Returns the actual number of booleans written, possibly zero.
src
the array to write
offset
the first index to use
length
the number of booleans to write
returns
the number of booleans written
def writeSomeBooleans(src: Array[Boolean]): Int
Writes at most src.length booleans of src.
Writes at most src.length booleans of src. Returns the actual number of booleans written, possibly zero.
src
the array to write
returns
the number of booleans written
def writeSomeDoubles(src: Array[Double], offset: Int, length: Int): Int
Writes at most length doubles of src, starting at index offset.
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.
src
the array to write
offset
the first index to use
length
the number of doubles to write
returns
the number of doubles written
def writeSomeDoubles(src: Array[Double]): Int
Writes at most src.length doubles of src.
Writes at most src.length doubles of src. Uses big-endian for each value. Returns the actual number of doubles written, possibly zero.
src
the array to write
returns
the number of doubles written
def writeSomeDoublesLE(src: Array[Double], offset: Int, length: Int): Int
Writes at most length doubles of src, starting at index offset.
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.
src
the array to write
offset
the first index to use
length
the number of doubles to write
returns
the number of doubles written
def writeSomeDoublesLE(src: Array[Double]): Int
Writes at most src.length doubles of src for each value.
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.
src
the array to write
returns
the number of doubles written
def writeSomeFloats(src: Array[Float], offset: Int, length: Int): Int
Writes at most length floats of src, starting at index offset.
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.
src
the array to write
offset
the first index to use
length
the number of floats to write
returns
the number of floats written
def writeSomeFloats(src: Array[Float]): Int
Writes at most src.length floats of src.
Writes at most src.length floats of src. Uses big-endian for each value. Returns the actual number of floats written, possibly zero.
src
the array to write
returns
the number of floats written
def writeSomeFloatsLE(src: Array[Float], offset: Int, length: Int): Int
Writes at most length floats of src, starting at index offset.
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.
src
the array to write
offset
the first index to use
length
the number of floats to write
returns
the number of floats written
def writeSomeFloatsLE(src: Array[Float]): Int
Writes at most src.length floats of src for each value.
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.
src
the array to write
returns
the number of floats written
def writeSomeInts(src: Array[Int], offset: Int, length: Int): Int
Writes at most length ints of src, starting at index offset.
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.
src
the array to write
offset
the first index to use
length
the number of ints to write
returns
the number of ints written
def writeSomeInts(src: Array[Int]): Int
Writes at most src.length ints of src.
Writes at most src.length ints of src. Uses big-endian for each value. Returns the actual number of ints written, possibly zero.
src
the array to write
returns
the number of ints written
def writeSomeIntsLE(src: Array[Int], offset: Int, length: Int): Int
Writes at most length ints of src, starting at index offset.
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.
src
the array to write
offset
the first index to use
length
the number of ints to write
returns
the number of ints written
def writeSomeIntsLE(src: Array[Int]): Int
Writes at most src.length ints of src for each value.
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.
src
the array to write
returns
the number of ints written
def writeSomeLongs(src: Array[Long], offset: Int, length: Int): Int
Writes at most length longs of src, starting at index offset.
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.
src
the array to write
offset
the first index to use
length
the number of longs to write
returns
the number of longs written
def writeSomeLongs(src: Array[Long]): Int
Writes at most src.length longs of src.
Writes at most src.length longs of src. Uses big-endian for each value. Returns the actual number of longs written, possibly zero.
src
the array to write
returns
the number of longs written
def writeSomeLongsLE(src: Array[Long], offset: Int, length: Int): Int
Writes at most length longs of src, starting at index offset.
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.
src
the array to write
offset
the first index to use
length
the number of longs to write
returns
the number of longs written
def writeSomeLongsLE(src: Array[Long]): Int
Writes at most src.length longs of src for each value.
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.
src
the array to write
returns
the number of longs written
def writeSomeShorts(src: Array[Short], offset: Int, length: Int): Int
Writes at most length shorts of src, starting at index offset.
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.
src
the array to write
offset
the first index to use
length
the number of shorts to write
returns
the number of shorts written
def writeSomeShorts(src: Array[Short]): Int
Writes at most src.length shorts of src.
Writes at most src.length shorts of src. Uses big-endian for each value. Returns the actual number of shorts written, possibly zero.
src
the array to write
returns
the number of shorts written
def writeSomeShortsLE(src: Array[Short], offset: Int, length: Int): Int
Writes at most length shorts of src, starting at index offset.
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.
src
the array to write
offset
the first index to use
length
the number of shorts to write
returns
the number of shorts written
def writeSomeShortsLE(src: Array[Short]): Int
Writes at most src.length shorts of src for each value.
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.
src
the array to write
returns
the number of shorts written
final def writeString(str: String, charset: Charset = UTF_8): Unit
Writes a String with the given charset.
Writes a String with the given charset. The written data isn't prefixed by its length.
str
the value to write
charset
the charset to encode the String with
final def writeUUID(uuid: UUID): Unit
Writes a UUID as two 8-bytes big-endian integers, most significant bits first.
Writes a UUID as two 8-bytes big-endian integers, most significant bits first.
uuid
the value to write
def writeVarInt(i: Int): Unit
Writes a variable-length int using the normal/unsigned encoding.
Writes a variable-length int using the normal/unsigned encoding.
i
the value to write
def writeVarLong(l: Long): Unit
Writes a variable-length long using the normal/unsigned encoding.
Writes a variable-length long using the normal/unsigned encoding.
l
the value to write
final def writeVarString(csq: CharSequence, charset: Charset = UTF_8): Unit
Writes a CharSequence with the given charset, preceded by its length written as a normal VarInt.
Writes a CharSequence with the given charset, preceded by its length written as a normal VarInt.
csq
the value to write
charset
the charset to CharSequence the String with

Packages

NiolOutput

trait NiolOutput extends AnyRef

Abstract Value Members

Concrete Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

NiolOutput 

trait NiolOutput extends AnyRef

Abstract Value Members

Concrete Value Members

Inherited from AnyRef

Inherited from Any

Ungrouped

NiolOutput