Packages

abstract class NiolBuffer extends NiolInput with NiolOutput

Linear Supertypes
NiolOutput, NiolInput, AnyRef, Any
Known Subclasses
BiBuffer, CircularBuffer
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. NiolBuffer
  2. NiolOutput
  3. NiolInput
  4. AnyRef
  5. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new NiolBuffer()

Abstract Value Members

  1. abstract def _read(to: NiolBuffer, len: Int): Unit

    Implements read without necessarily checking for available space.

    Implements read without necessarily checking for available space.

    Attributes
    protected[niol]
  2. abstract def _read(to: ByteBuffer, len: Int): Unit

    Implements read without necessarily checking for available space.

    Implements read without necessarily checking for available space.

    Attributes
    protected[niol]
  3. abstract def _read(to: Array[Byte], off: Int, len: Int): Unit

    Implements read without necessarily checking for available space.

    Implements read without necessarily checking for available space.

    Attributes
    protected[niol]
  4. abstract def _read(): Byte

    Implements read without necessarily checking for available data.

    Implements read without necessarily checking for available data.

    Attributes
    protected[niol]
    Definition Classes
    NiolInput
  5. 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]
    Definition Classes
    NiolOutput
  6. 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]
    Definition Classes
    NiolOutput
  7. 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]
    Definition Classes
    NiolOutput
  8. abstract def advance(n: Int): Unit

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

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

    n

    the number of bytes to skip

  9. abstract def capacity: Int

    The buffer's capacity.

    The buffer's capacity.

    returns

    the current capcity

  10. abstract def clear(): Unit

    Makes the buffer empty.

    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.

  11. abstract def duplicate: NiolBuffer

    Returns a new buffer that shares its content with this buffer, but has independent read and write positions.

    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.

    returns

    the duplicate

  12. abstract def isEmpty: Boolean

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

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

    returns

    true if no byte can be read from this buffer

  13. abstract def isFull: Boolean

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

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

    returns

    true if no byte can be written to this buffer

  14. abstract def readSome(dst: OutputStream): Int

    Reads some bytes and writes them to dst.

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

    dst

    the channel to write to

    returns

    the number of bytes read

  15. abstract def readSome(dst: GatheringByteChannel): Int

    Reads some bytes and writes them to dst.

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

    dst

    the channel to write to

    returns

    the number of bytes read

  16. abstract def readSome(dst: NiolBuffer): Int

    Reads at most dst.writableBytes bytes into dst.

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

    dst

    the buffer to fill

    Definition Classes
    NiolInput
  17. abstract def readableBytes: Int

    The number of bytes that can be read from this buffer.

    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.

    returns

    n > 0 if can read n bytes, 0 if closed input or empty buffer

  18. abstract def slice(length: Int): NiolBuffer

    Creates a "slice" that gives a limited access to the next length readable bytes.

    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.

    length

    the length of the slice

    returns

    the slice

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

    Definition Classes
    NiolOutput
  20. abstract def writableSlice(length: Int): NiolBuffer

    Creates a "slice" that gives a limited access to the next length writable bytes.

    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.

    length

    the length of the slice

    returns

    the writable slice

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

    Definition Classes
    NiolOutput
  22. abstract def writeSome(src: InputStream): Int

    Writes some bytes from src.

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

    src

    the stream providing the data

    returns

    the number of bytes read from src, or -1 if the end of the stream has been reached

  23. abstract def writeSome(src: ScatteringByteChannel): Int

    Writes at most maxBytes bytes from src.

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

    src

    the channel providing the data

    returns

    the number of bytes read from src, or -1 if the end of the stream has been reached

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

    Definition Classes
    NiolOutput

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def +(other: NiolBuffer): BiBuffer

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

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

    other

    the other buffer

    returns

    a new BiBuffer(thisBuffer, other)

  4. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  5. 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]
    Definition Classes
    NiolOutput
  6. 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]
    Definition Classes
    NiolOutput
  7. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  8. 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]
    Definition Classes
    NiolOutput
  9. def checkReadable(n: Int): Unit

    Checks if at least n bytes can be written

    Checks if at least n bytes can be written

    Attributes
    protected[niol]
  10. 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]
    Definition Classes
    NiolOutput
  11. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  12. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  13. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  14. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  15. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  16. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  17. 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

    Definition Classes
    NiolBuffer → NiolOutput → NiolInput
  18. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  19. def isReadable: Boolean

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

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

    returns

    true if at least one byte can be read, false otherwise

    Definition Classes
    NiolBuffer → NiolInput
  20. 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

    Definition Classes
    NiolBuffer → NiolOutput
  21. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  22. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  23. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  24. def r(): Byte

    Reads a byte

    Reads a byte

    Definition Classes
    NiolInput
  25. def read(dst: NiolBuffer): Unit

    Fills the given NiolBuffer.

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

    dst

    the buffer to fill

    Definition Classes
    NiolBuffer → NiolInput
  26. def read(dst: ByteBuffer): Unit

    Fills the given ByteBuffer.

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

    dst

    the buffer to fill

    Definition Classes
    NiolBuffer → NiolInput
  27. def readBool(): Boolean

    Reads a boolean.

    Reads a boolean.

    Definition Classes
    NiolInput
  28. def readBoolF(falseValue: Byte): Boolean

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

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

    Definition Classes
    NiolInput
  29. def readBoolT(trueValue: Byte): Boolean

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

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

    Definition Classes
    NiolInput
  30. def readBoolean(): Boolean

    Reads a boolean

    Reads a boolean

    Definition Classes
    NiolInput
  31. final def readByte(): Byte

    Reads a byte

    Reads a byte

    Definition Classes
    NiolInput
  32. def readBytes(dst: Array[Byte], offset: Int, length: Int): Unit

    Reads the next length bytes and put them into dst at the given offset.

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

    dst

    the array to fill

    offset

    the first index to use

    length

    the number of bytes to read

    Definition Classes
    NiolBuffer → NiolInput
  33. def readBytes(dst: Array[Byte]): Unit

    Reads the next dst.length bytes and put them into dst.

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

    dst

    the array to fill

    Definition Classes
    NiolInput
  34. def readBytes(n: Int): Array[Byte]

    Reads the next n bytes.

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

    n

    the number of bytes to read

    Definition Classes
    NiolInput
  35. def readChar(): Char

    Reads a big-endian char

    Reads a big-endian char

    Definition Classes
    NiolInput
  36. def readCharLE(): Char

    Reads a little-endian char

    Reads a little-endian char

    Definition Classes
    NiolInput
  37. final def readCharSequence(bytesLength: Int, charset: Charset = UTF_8): CharSequence

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

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

    Definition Classes
    NiolInput
  38. def readDouble(): Double

    Reads a big-endian 8-bytes double

    Reads a big-endian 8-bytes double

    Definition Classes
    NiolInput
  39. def readDoubleLE(): Double

    Reads a little-endian 8-bytes double

    Reads a little-endian 8-bytes double

    Definition Classes
    NiolInput
  40. def readDoubles(dst: Array[Double], offset: Int, length: Int): Unit

    Reads the next length doubles and put them into dst at the given offset.

    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.

    dst

    the array to fill

    offset

    the first index to use

    length

    the number of doubles to read

    Definition Classes
    NiolInput
  41. def readDoubles(dst: Array[Double]): Unit

    Reads the next dst.length doubles and put them into dst.

    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.

    dst

    the array to fill

    Definition Classes
    NiolInput
  42. def readDoubles(n: Int): Array[Double]

    Reads the next n doubles.

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

    n

    the number of doubles to read

    Definition Classes
    NiolInput
  43. def readDoublesLE(dst: Array[Double], offset: Int, length: Int): Unit

    Reads the next length doubles and put them into dst at the given offset.

    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.

    dst

    the array to fill

    offset

    the first index to use

    length

    the number of doubles to read

    Definition Classes
    NiolInput
  44. def readDoublesLE(dst: Array[Double]): Unit

    Reads the next dst.length doubles and put them into dst.

    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.

    dst

    the array to fill

    Definition Classes
    NiolInput
  45. def readDoublesLE(n: Int): Array[Double]

    Reads the next n doubles.

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

    n

    the number of doubles to read

    Definition Classes
    NiolInput
  46. def readFloat(): Float

    Reads a big-endian 4-bytes float

    Reads a big-endian 4-bytes float

    Definition Classes
    NiolInput
  47. def readFloatLE(): Float

    Reads a little-endian 4-bytes float

    Reads a little-endian 4-bytes float

    Definition Classes
    NiolInput
  48. def readFloats(dst: Array[Float], offset: Int, length: Int): Unit

    Reads the next length floats and put them into dst at the given offset.

    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.

    dst

    the array to fill

    offset

    the first index to use

    length

    the number of floats to read

    Definition Classes
    NiolInput
  49. def readFloats(dst: Array[Float]): Unit

    Reads the next dst.length floats and put them into dst.

    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.

    dst

    the array to fill

    Definition Classes
    NiolInput
  50. def readFloats(n: Int): Array[Float]

    Reads the next n floats.

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

    n

    the number of floats to read

    Definition Classes
    NiolInput
  51. def readFloatsLE(dst: Array[Float], offset: Int, length: Int): Unit

    Reads the next length floats and put them into dst at the given offset.

    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.

    dst

    the array to fill

    offset

    the first index to use

    length

    the number of floats to read

    Definition Classes
    NiolInput
  52. def readFloatsLE(dst: Array[Float]): Unit

    Reads the next dst.length floats and put them into dst.

    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.

    dst

    the array to fill

    Definition Classes
    NiolInput
  53. def readFloatsLE(n: Int): Array[Float]

    Reads the next n floats.

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

    n

    the number of floats to read

    Definition Classes
    NiolInput
  54. def readInt(): Int

    Reads a big-endian 4-bytes integer

    Reads a big-endian 4-bytes integer

    Definition Classes
    NiolInput
  55. def readIntLE(): Int

    Reads a little-endian 4-bytes integer

    Reads a little-endian 4-bytes integer

    Definition Classes
    NiolInput
  56. def readInts(dst: Array[Int], offset: Int, length: Int): Unit

    Reads the next length ints and put them into dst at the given offset.

    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.

    dst

    the array to fill

    offset

    the first index to use

    length

    the number of ints to read

    Definition Classes
    NiolInput
  57. def readInts(dst: Array[Int]): Unit

    Reads the next dst.length ints and put them into dst.

    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.

    dst

    the array to fill

    Definition Classes
    NiolInput
  58. def readInts(n: Int): Array[Int]

    Reads the next n ints.

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

    n

    the number of ints to read

    Definition Classes
    NiolInput
  59. def readIntsLE(dst: Array[Int], offset: Int, length: Int): Unit

    Reads the next length ints and put them into dst at the given offset.

    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.

    dst

    the array to fill

    offset

    the first index to use

    length

    the number of ints to read

    Definition Classes
    NiolInput
  60. def readIntsLE(dst: Array[Int]): Unit

    Reads the next dst.length ints and put them into dst.

    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.

    dst

    the array to fill

    Definition Classes
    NiolInput
  61. def readIntsLE(n: Int): Array[Int]

    Reads the next n ints.

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

    n

    the number of ints to read

    Definition Classes
    NiolInput
  62. def readLong(): Long

    Reads a big-endian 8-bytes integer

    Reads a big-endian 8-bytes integer

    Definition Classes
    NiolInput
  63. def readLongLE(): Long

    Reads a little-endian 8-bytes integer

    Reads a little-endian 8-bytes integer

    Definition Classes
    NiolInput
  64. def readLongs(dst: Array[Long], offset: Int, length: Int): Unit

    Reads the next length longs and put them into dst at the given offset.

    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.

    dst

    the array to fill

    offset

    the first index to use

    length

    the number of longs to read

    Definition Classes
    NiolInput
  65. def readLongs(dst: Array[Long]): Unit

    Reads the next dst.length longs and put them into dst.

    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.

    dst

    the array to fill

    Definition Classes
    NiolInput
  66. def readLongs(n: Int): Array[Long]

    Reads the next n longs.

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

    n

    the number of longs to read

    Definition Classes
    NiolInput
  67. def readLongsLE(dst: Array[Long], offset: Int, length: Int): Unit

    Reads the next length longs and put them into dst at the given offset.

    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.

    dst

    the array to fill

    offset

    the first index to use

    length

    the number of longs to read

    Definition Classes
    NiolInput
  68. def readLongsLE(dst: Array[Long]): Unit

    Reads the next dst.length longs and put them into dst.

    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.

    dst

    the array to fill

    Definition Classes
    NiolInput
  69. def readLongsLE(n: Int): Array[Long]

    Reads the next n longs.

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

    n

    the number of longs to read

    Definition Classes
    NiolInput
  70. def readMedium(): Int

    Reads a big-endian 3-bytes integer

    Reads a big-endian 3-bytes integer

    Definition Classes
    NiolInput
  71. def readMediumLE(): Int

    Reads a little-endian 3-bytes integer

    Reads a little-endian 3-bytes integer

    Definition Classes
    NiolInput
  72. final def readSVarIntZigZag(maxBytes: Int = 5): Int

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

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

    Definition Classes
    NiolInput
  73. final def readSVarLongZigZag(maxBytes: Int = 10): Long

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

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

    Definition Classes
    NiolInput
  74. def readShort(): Short

    Reads a big-endian short

    Reads a big-endian short

    Definition Classes
    NiolInput
  75. final def readShortCharSequence(charset: Charset = UTF_8): CharSequence

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

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

    Definition Classes
    NiolInput
  76. final def readShortCharSequenceLE(charset: Charset = UTF_8): CharSequence

    Reads a little-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.

    Definition Classes
    NiolInput
  77. def readShortLE(): Short

    Reads a little-endian short

    Reads a little-endian short

    Definition Classes
    NiolInput
  78. final def readShortString(charset: Charset = UTF_8): String

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

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

    Definition Classes
    NiolInput
  79. final def readShortStringLE(charset: Charset = UTF_8): String

    Reads a little-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.

    Definition Classes
    NiolInput
  80. def readShorts(dst: Array[Short], offset: Int, length: Int): Unit

    Reads the next length shorts and put them into dst at the given offset.

    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.

    dst

    the array to fill

    offset

    the first index to use

    length

    the number of shorts to read

    Definition Classes
    NiolInput
  81. def readShorts(dst: Array[Short]): Unit

    Reads the next dst.length shorts and put them into dst.

    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.

    dst

    the array to fill

    Definition Classes
    NiolInput
  82. def readShorts(n: Int): Array[Short]

    Reads the next n shorts.

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

    n

    the number of shorts to read

    Definition Classes
    NiolInput
  83. def readShortsLE(dst: Array[Short], offset: Int, length: Int): Unit

    Reads the next length shorts and put them into dst at the given offset.

    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.

    dst

    the array to fill

    offset

    the first index to use

    length

    the number of shorts to read

    Definition Classes
    NiolInput
  84. def readShortsLE(dst: Array[Short]): Unit

    Reads the next dst.length shorts and put them into dst.

    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.

    dst

    the array to fill

    Definition Classes
    NiolInput
  85. def readShortsLE(n: Int): Array[Short]

    Reads the next n shorts.

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

    n

    the number of shorts to read

    Definition Classes
    NiolInput
  86. def readSome(dst: ByteBuffer): Int

    Reads at most dst.remaining() bytes into dst.

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

    dst

    the buffer to fill

    Definition Classes
    NiolBuffer → NiolInput
  87. def readSomeBytes(dst: Array[Byte], offset: Int, length: Int): Int

    Reads at most length bytes and put them into dst at the given offset.

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

    dst

    the array to fill

    offset

    the first index to use

    returns

    the number of bytes read

    Definition Classes
    NiolBuffer → NiolInput
  88. def readSomeBytes(dst: Array[Byte]): Int

    Reads at most dst.length bytes into dst.

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

    dst

    the array to fill

    returns

    the number of bytes read

    Definition Classes
    NiolInput
  89. final def readString(bytesLength: Int, charset: Charset = UTF_8): String

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

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

    Definition Classes
    NiolInput
  90. final def readUUID(): UUID

    Reads a big-endian 16-bytes UUID

    Reads a big-endian 16-bytes UUID

    Definition Classes
    NiolInput
  91. final def readUnsignedByte(): Int

    Reads an unsigned byte as an int

    Reads an unsigned byte as an int

    Definition Classes
    NiolInput
  92. final def readUnsignedInt(): Long

    Reads a big-endian unsigned int as a long

    Reads a big-endian unsigned int as a long

    Definition Classes
    NiolInput
  93. final def readUnsignedIntLE(): Long

    Reads a little-endian unsigned int as a long

    Reads a little-endian unsigned int as a long

    Definition Classes
    NiolInput
  94. final def readUnsignedMedium(): Int

    Reads a big-endian unsigned medium as an int

    Reads a big-endian unsigned medium as an int

    Definition Classes
    NiolInput
  95. final def readUnsignedMediumLE(): Int

    Reads a little-endian unsigned medium as an int

    Reads a little-endian unsigned medium as an int

    Definition Classes
    NiolInput
  96. final def readUnsignedShort(): Int

    Reads a big-endian unsigned short as an int

    Reads a big-endian unsigned short as an int

    Definition Classes
    NiolInput
  97. final def readUnsignedShortLE(): Int

    Reads a little-endian unsigned short as an int

    Reads a little-endian unsigned short as an int

    Definition Classes
    NiolInput
  98. final def readVarCharSequence(charset: Charset = UTF_8): CharSequence

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

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

    Definition Classes
    NiolInput
  99. def readVarInt(maxBytes: Int = 5): Int

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

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

    Definition Classes
    NiolInput
  100. def readVarLong(maxBytes: Int = 10): Long

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

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

    Definition Classes
    NiolInput
  101. final def readVarString(charset: Charset = UTF_8): String

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

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

    Definition Classes
    NiolInput
  102. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  103. def toArray(): Array[Byte]

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

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

    returns

    the byte array containing all the bytes read

  104. def toString(): String
    Definition Classes
    NiolBuffer → AnyRef → Any
  105. def tryRead(): Int

    Attempts to read a byte.

    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.

    returns

    the byte value in range 0-255, or -1 if the input is empty

    Definition Classes
    NiolInput
  106. 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

    Definition Classes
    NiolOutput
  107. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  108. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  109. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... ) @native()
  110. 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

    Definition Classes
    NiolOutput
  111. 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

    Definition Classes
    NiolOutput
  112. 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

    Definition Classes
    NiolOutput
  113. def write(b: Byte): Unit

    Writes a byte.

    Writes a byte.

    b

    the byte to write

    Definition Classes
    NiolOutput
  114. 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

    Definition Classes
    NiolOutput
  115. 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

    Definition Classes
    NiolOutput
  116. 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

    Definition Classes
    NiolOutput
  117. 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

    Definition Classes
    NiolOutput
  118. 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

    Definition Classes
    NiolOutput
  119. 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

    Definition Classes
    NiolOutput
  120. 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

    Definition Classes
    NiolOutput
  121. final def writeByte(b: Byte): Unit

    Writes a byte.

    Writes a byte.

    b

    the byte to write

    Definition Classes
    NiolOutput
  122. final def writeChar(c: Char): Unit

    Writes a big-endian char.

    Writes a big-endian char.

    c

    the value to write

    Definition Classes
    NiolOutput
  123. final def writeCharLE(c: Char): Unit

    Writes a little-endian char.

    Writes a little-endian char.

    c

    the value to write

    Definition Classes
    NiolOutput
  124. 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

    Definition Classes
    NiolOutput
  125. def writeDouble(d: Double): Unit

    Writes a big-endian 8-bytes double.

    Writes a big-endian 8-bytes double.

    d

    the value to write

    Definition Classes
    NiolOutput
  126. def writeDoubleLE(d: Double): Unit

    Writes a little-endian 8-bytes double.

    Writes a little-endian 8-bytes double.

    d

    the value to write

    Definition Classes
    NiolOutput
  127. 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

    Definition Classes
    NiolOutput
  128. 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

    Definition Classes
    NiolOutput
  129. 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

    Definition Classes
    NiolOutput
  130. 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

    Definition Classes
    NiolOutput
  131. 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

    Definition Classes
    NiolOutput
  132. def writeFloat(f: Float): Unit

    Writes a big-endian 4-bytes float.

    Writes a big-endian 4-bytes float.

    f

    the value to write

    Definition Classes
    NiolOutput
  133. 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

    Definition Classes
    NiolOutput
  134. def writeFloatLE(f: Float): Unit

    Writes a little-endian 4-bytes float.

    Writes a little-endian 4-bytes float.

    f

    the value to write

    Definition Classes
    NiolOutput
  135. 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

    Definition Classes
    NiolOutput
  136. 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

    Definition Classes
    NiolOutput
  137. 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

    Definition Classes
    NiolOutput
  138. 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

    Definition Classes
    NiolOutput
  139. def writeInt(i: Int): Unit

    Writes a big-endian 4-bytes integer.

    Writes a big-endian 4-bytes integer.

    i

    the value to write

    Definition Classes
    NiolOutput
  140. def writeIntLE(i: Int): Unit

    Writes a little-endian 4-bytes integer.

    Writes a little-endian 4-bytes integer.

    i

    the value to write

    Definition Classes
    NiolOutput
  141. 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

    Definition Classes
    NiolOutput
  142. 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

    Definition Classes
    NiolOutput
  143. 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

    Definition Classes
    NiolOutput
  144. 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

    Definition Classes
    NiolOutput
  145. def writeLong(l: Long): Unit

    Writes a big-endian 8-bytes integer.

    Writes a big-endian 8-bytes integer.

    l

    the value to write

    Definition Classes
    NiolOutput
  146. def writeLongLE(l: Long): Unit

    Writes a little-endian 8-bytes integer.

    Writes a little-endian 8-bytes integer.

    l

    the value to write

    Definition Classes
    NiolOutput
  147. 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

    Definition Classes
    NiolOutput
  148. 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

    Definition Classes
    NiolOutput
  149. 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

    Definition Classes
    NiolOutput
  150. 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

    Definition Classes
    NiolOutput
  151. def writeMedium(m: Int): Unit

    Writes a big-endian 3-bytes integer.

    Writes a big-endian 3-bytes integer.

    m

    the value to write

    Definition Classes
    NiolOutput
  152. def writeMediumLE(m: Int): Unit

    Writes a little-endian 3-bytes integer.

    Writes a little-endian 3-bytes integer.

    m

    the value to write

    Definition Classes
    NiolOutput
  153. 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

    Definition Classes
    NiolOutput
  154. 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

    Definition Classes
    NiolOutput
  155. def writeShort(i: Int): Unit

    Writes a big-endian short.

    Writes a big-endian short.

    i

    the value to write

    Definition Classes
    NiolOutput
  156. final def writeShort(s: Short): Unit

    Writes a big-endian short.

    Writes a big-endian short.

    s

    the value to write

    Definition Classes
    NiolOutput
  157. def writeShortLE(i: Int): Unit

    Writes a little-endian short.

    Writes a little-endian short.

    i

    the value to write

    Definition Classes
    NiolOutput
  158. final def writeShortLE(s: Short): Unit

    Writes a little-endian short.

    Writes a little-endian short.

    s

    the value to write

    Definition Classes
    NiolOutput
  159. 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

    Definition Classes
    NiolOutput
  160. 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

    Definition Classes
    NiolOutput
  161. 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

    Definition Classes
    NiolOutput
  162. 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

    Definition Classes
    NiolOutput
  163. 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

    Definition Classes
    NiolOutput
  164. 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

    Definition Classes
    NiolOutput
  165. 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

    Definition Classes
    NiolOutput
  166. 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

    Definition Classes
    NiolOutput
  167. 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

    Definition Classes
    NiolOutput
  168. 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

    Definition Classes
    NiolOutput
  169. 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

    Definition Classes
    NiolOutput
  170. 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

    Definition Classes
    NiolOutput
  171. 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

    Definition Classes
    NiolOutput
  172. 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

    Definition Classes
    NiolOutput
  173. 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

    Definition Classes
    NiolOutput
  174. 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

    Definition Classes
    NiolOutput
  175. 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

    Definition Classes
    NiolOutput
  176. 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

    Definition Classes
    NiolOutput
  177. 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

    Definition Classes
    NiolOutput
  178. 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

    Definition Classes
    NiolOutput
  179. 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

    Definition Classes
    NiolOutput
  180. 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

    Definition Classes
    NiolOutput
  181. 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

    Definition Classes
    NiolOutput
  182. 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

    Definition Classes
    NiolOutput
  183. 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

    Definition Classes
    NiolOutput
  184. 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

    Definition Classes
    NiolOutput
  185. 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

    Definition Classes
    NiolOutput
  186. 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

    Definition Classes
    NiolOutput
  187. 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

    Definition Classes
    NiolOutput
  188. 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

    Definition Classes
    NiolOutput
  189. 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

    Definition Classes
    NiolOutput
  190. 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

    Definition Classes
    NiolOutput
  191. 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

    Definition Classes
    NiolOutput
  192. 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

    Definition Classes
    NiolOutput
  193. 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

    Definition Classes
    NiolOutput
  194. 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

    Definition Classes
    NiolOutput

Inherited from NiolOutput

Inherited from NiolInput

Inherited from AnyRef

Inherited from Any

Ungrouped