BufferAllocReadChannel

Instance Constructors

new BufferAllocReadChannel(id: Int, path: String, startFrame: Int, numFrames: Int, channels: List[Int], completion: Option[Packet])

id
the identifier to use for the buffer. It must denote a currently un-allocated buffer and be greater than or equal to zero and less than the maximum number of buffers.
path
the path of the audio-file to read. Since the server is an independent process, this must resolve with respect to the server's current working directory. If the server is running on a remote node, the path will be resolved in the server's local file system.
startFrame
the offset in frames into the audio-file to begin reading from
numFrames
the number of frames to read which will be the size of the allocated buffer. The special value of -1 denotes that the number of frames available in the file from the given offset is used (the entire file will be read).
channels
a sequence of channel indices to read. Zero corresponds to the first channel of the file.

Type Members

type Self = Message

Attributes
protected[this]
Definition Classes
TraversableLike
class WithFilter extends FilterMonadic[A, Repr]

Definition Classes
TraversableLike

Value Members

final def !=(arg0: Any): Boolean

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

Definition Classes
AnyRef → Any
def ++[B >: Any, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Message, B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def ++:[B >: Any, That](that: Traversable[B])(implicit bf: CanBuildFrom[Message, B, That]): That

Definition Classes
TraversableLike
def ++:[B >: Any, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Message, B, That]): That

Definition Classes
TraversableLike
def +:[B >: Any, That](elem: B)(implicit bf: CanBuildFrom[Message, B, That]): That

Definition Classes
SeqLike → GenSeqLike
def /:[B](z: B)(op: (B, Any) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def :+[B >: Any, That](elem: B)(implicit bf: CanBuildFrom[Message, B, That]): That

Definition Classes
SeqLike → GenSeqLike
def :\[B](z: B)(op: (Any, B) ⇒ B): B

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

Definition Classes
AnyRef → Any
def addString(b: StringBuilder): StringBuilder

Definition Classes
TraversableOnce
def addString(b: StringBuilder, sep: String): StringBuilder

Definition Classes
TraversableOnce
def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

Definition Classes
TraversableOnce
def aggregate[B](z: ⇒ B)(seqop: (B, Any) ⇒ B, combop: (B, B) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def andThen[C](k: (Any) ⇒ C): PartialFunction[Int, C]

Definition Classes
PartialFunction → Function1
def apply(idx: Int): Any

Definition Classes
Message → SeqLike → GenSeqLike → Function1
def applyOrElse[A1 <: Int, B1 >: Any](x: A1, default: (A1) ⇒ B1): B1

Definition Classes
PartialFunction
val args: Any*

Definition Classes
Message
final def asInstanceOf[T0]: T0

Definition Classes
Any
def canEqual(that: Any): Boolean

Definition Classes
IterableLike → Equals
val channels: List[Int]

a sequence of channel indices to read.
a sequence of channel indices to read. Zero corresponds to the first channel of the file.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def collect[B, That](pf: PartialFunction[Any, B])(implicit bf: CanBuildFrom[Message, B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def collectFirst[B](pf: PartialFunction[Any, B]): Option[B]

Definition Classes
TraversableOnce
def combinations(n: Int): Iterator[Message]

Definition Classes
SeqLike
def companion: GenericCompanion[LinearSeq]

Definition Classes
LinearSeq → Seq → GenSeq → Iterable → GenIterable → Traversable → GenTraversable → GenericTraversableTemplate
val completion: Option[Packet]

Definition Classes
BufferAllocReadChannel → HasCompletion
def compose[A](g: (A) ⇒ Int): (A) ⇒ Any

Definition Classes
Function1
Annotations
@unspecialized()
def contains[A1 >: Any](elem: A1): Boolean

Definition Classes
SeqLike
def containsSlice[B](that: GenSeq[B]): Boolean

Definition Classes
SeqLike
def copyToArray[B >: Any](xs: Array[B], start: Int, len: Int): Unit

Definition Classes
IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
def copyToArray[B >: Any](xs: Array[B]): Unit

Definition Classes
TraversableOnce → GenTraversableOnce
def copyToArray[B >: Any](xs: Array[B], start: Int): Unit

Definition Classes
TraversableOnce → GenTraversableOnce
def copyToBuffer[B >: Any](dest: scala.collection.mutable.Buffer[B]): Unit

Definition Classes
TraversableOnce
final def corresponds[B](that: GenSeq[B])(p: (Any, B) ⇒ Boolean): Boolean

Definition Classes
LinearSeqLike → SeqLike → GenSeqLike
Annotations
@tailrec()
def count(p: (Any) ⇒ Boolean): Int

Definition Classes
TraversableOnce → GenTraversableOnce
def diff[B >: Any](that: GenSeq[B]): Message

Definition Classes
SeqLike → GenSeqLike
def distinct: Message

Definition Classes
SeqLike → GenSeqLike
def drop(n: Int): Message

Definition Classes
Message → IterableLike → TraversableLike → GenTraversableLike
def dropRight(n: Int): Message

Definition Classes
IterableLike
def dropWhile(p: (Any) ⇒ Boolean): Message

Definition Classes
TraversableLike → GenTraversableLike
def encode(c: PacketCodec, b: ByteBuffer): Unit

Definition Classes
Message → Packet
def encodedSize(c: PacketCodec): Int

Definition Classes
Message → Packet
def endsWith[B](that: GenSeq[B]): Boolean

Definition Classes
SeqLike → GenSeqLike
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
Message → GenSeqLike → Equals → AnyRef → Any
def exists(p: (Any) ⇒ Boolean): Boolean

Definition Classes
IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
def filter(p: (Any) ⇒ Boolean): Message

Definition Classes
TraversableLike → GenTraversableLike
def filterNot(p: (Any) ⇒ Boolean): Message

Definition Classes
TraversableLike → GenTraversableLike
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def find(p: (Any) ⇒ Boolean): Option[Any]

Definition Classes
IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
def flatMap[B, That](f: (Any) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[Message, B, That]): That

Definition Classes
TraversableLike → GenTraversableLike → FilterMonadic
def flatten[B](implicit asTraversable: (Any) ⇒ GenTraversableOnce[B]): LinearSeq[B]

Definition Classes
GenericTraversableTemplate
def fold[A1 >: Any](z: A1)(op: (A1, A1) ⇒ A1): A1

Definition Classes
TraversableOnce → GenTraversableOnce
def foldLeft[B](z: B)(op: (B, Any) ⇒ B): B

Definition Classes
TraversableOnce → GenTraversableOnce
def foldRight[B](z: B)(op: (Any, B) ⇒ B): B

Definition Classes
IterableLike → TraversableOnce → GenTraversableOnce
def forall(p: (Any) ⇒ Boolean): Boolean

Definition Classes
IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
def foreach[U](f: (Any) ⇒ U): Unit

Definition Classes
IterableLike → TraversableLike → GenTraversableLike → TraversableOnce → GenTraversableOnce → FilterMonadic
def genericBuilder[B]: Builder[B, LinearSeq[B]]

Definition Classes
GenericTraversableTemplate
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def groupBy[K](f: (Any) ⇒ K): Map[K, Message]

Definition Classes
TraversableLike → GenTraversableLike
def grouped(size: Int): Iterator[Message]

Definition Classes
IterableLike
def hasDefiniteSize: Boolean

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
def hashCode(): Int

Definition Classes
Message → LinearSeqLike → GenSeqLike → AnyRef → Any
def head: Any

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def headOption: Option[Any]

Definition Classes
TraversableLike → GenTraversableLike
val id: Int

the identifier to use for the buffer.
the identifier to use for the buffer. It must denote a currently un-allocated buffer and be greater than or equal to zero and less than the maximum number of buffers.
def indexOf[B >: Any](elem: B, from: Int): Int

Definition Classes
GenSeqLike
def indexOf[B >: Any](elem: B): Int

Definition Classes
GenSeqLike
def indexOfSlice[B >: Any](that: GenSeq[B], from: Int): Int

Definition Classes
SeqLike
def indexOfSlice[B >: Any](that: GenSeq[B]): Int

Definition Classes
SeqLike
def indexWhere(p: (Any) ⇒ Boolean, from: Int): Int

Definition Classes
SeqLike → GenSeqLike
def indexWhere(p: (Any) ⇒ Boolean): Int

Definition Classes
GenSeqLike
def indices: Range

Definition Classes
SeqLike
def init: Message

Definition Classes
TraversableLike → GenTraversableLike
def inits: Iterator[Message]

Definition Classes
TraversableLike
def intersect[B >: Any](that: GenSeq[B]): Message

Definition Classes
SeqLike → GenSeqLike
def isComparable(other: Any): Boolean

Attributes
protected
Definition Classes
Message
def isDefinedAt(idx: Int): Boolean

Definition Classes
GenSeqLike
def isEmpty: Boolean

Definition Classes
SeqLike → IterableLike → TraversableLike → TraversableOnce → GenTraversableOnce
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def isSynchronous: Boolean

Definition Classes
AsyncSend → Send
final def isTraversableAgain: Boolean

Definition Classes
TraversableLike → GenTraversableLike → GenTraversableOnce
def iterator: Iterator[Any]

Definition Classes
Message → LinearSeqLike → IterableLike → GenIterableLike
def last: Any

Definition Classes
TraversableLike → GenTraversableLike
def lastIndexOf[B >: Any](elem: B, end: Int): Int

Definition Classes
GenSeqLike
def lastIndexOf[B >: Any](elem: B): Int

Definition Classes
GenSeqLike
def lastIndexOfSlice[B >: Any](that: GenSeq[B], end: Int): Int

Definition Classes
SeqLike
def lastIndexOfSlice[B >: Any](that: GenSeq[B]): Int

Definition Classes
SeqLike
def lastIndexWhere(p: (Any) ⇒ Boolean, end: Int): Int

Definition Classes
SeqLike → GenSeqLike
def lastIndexWhere(p: (Any) ⇒ Boolean): Int

Definition Classes
GenSeqLike
def lastOption: Option[Any]

Definition Classes
TraversableLike → GenTraversableLike
def length: Int

Definition Classes
Message → SeqLike → GenSeqLike
def lengthCompare(len: Int): Int

Definition Classes
SeqLike
def lift: (Int) ⇒ Option[Any]

Definition Classes
PartialFunction
def map[B, That](f: (Any) ⇒ B)(implicit bf: CanBuildFrom[Message, B, That]): That

Definition Classes
TraversableLike → GenTraversableLike → FilterMonadic
def max[B >: Any](implicit cmp: Ordering[B]): Any

Definition Classes
TraversableOnce → GenTraversableOnce
def maxBy[B](f: (Any) ⇒ B)(implicit cmp: Ordering[B]): Any

Definition Classes
TraversableOnce → GenTraversableOnce
def min[B >: Any](implicit cmp: Ordering[B]): Any

Definition Classes
TraversableOnce → GenTraversableOnce
def minBy[B](f: (Any) ⇒ B)(implicit cmp: Ordering[B]): Any

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString: String

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString(sep: String): String

Definition Classes
TraversableOnce → GenTraversableOnce
def mkString(start: String, sep: String, end: String): String

Definition Classes
TraversableOnce → GenTraversableOnce
val name: String

Definition Classes
Message → Packet
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def newBuilder: Builder[Any, Message]

Definition Classes
Message → GenericTraversableTemplate → TraversableLike → HasNewBuilder
def nonEmpty: Boolean

Definition Classes
TraversableOnce → GenTraversableOnce
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val numFrames: Int

the number of frames to read which will be the size of the allocated buffer.
the number of frames to read which will be the size of the allocated buffer. The special value of -1 denotes that the number of frames available in the file from the given offset is used (the entire file will be read).
def orElse[A1 <: Int, B1 >: Any](that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

Definition Classes
PartialFunction
def padTo[B >: Any, That](len: Int, elem: B)(implicit bf: CanBuildFrom[Message, B, That]): That

Definition Classes
SeqLike → GenSeqLike
def par: ParSeq[Any]

Definition Classes
Parallelizable
def parCombiner: Combiner[Any, ParSeq[Any]]

Attributes
protected[this]
Definition Classes
SeqLike → TraversableLike → Parallelizable
def partition(p: (Any) ⇒ Boolean): (Message, Message)

Definition Classes
TraversableLike → GenTraversableLike
def patch[B >: Any, That](from: Int, patch: GenSeq[B], replaced: Int)(implicit bf: CanBuildFrom[Message, B, That]): That

Definition Classes
SeqLike → GenSeqLike
val path: String

the path of the audio-file to read.
the path of the audio-file to read. Since the server is an independent process, this must resolve with respect to the server's current working directory. If the server is running on a remote node, the path will be resolved in the server's local file system.
def permutations: Iterator[Message]

Definition Classes
SeqLike
def prefixLength(p: (Any) ⇒ Boolean): Int

Definition Classes
GenSeqLike
def product[B >: Any](implicit num: Numeric[B]): B

Definition Classes
TraversableOnce → GenTraversableOnce
def reduce[A1 >: Any](op: (A1, A1) ⇒ A1): A1

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceLeft[B >: Any](op: (B, Any) ⇒ B): B

Definition Classes
TraversableOnce
def reduceLeftOption[B >: Any](op: (B, Any) ⇒ B): Option[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceOption[A1 >: Any](op: (A1, A1) ⇒ A1): Option[A1]

Definition Classes
TraversableOnce → GenTraversableOnce
def reduceRight[B >: Any](op: (Any, B) ⇒ B): B

Definition Classes
IterableLike → TraversableOnce → GenTraversableOnce
def reduceRightOption[B >: Any](op: (Any, B) ⇒ B): Option[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def repr: Message

Definition Classes
TraversableLike → GenTraversableLike
def reverse: Message

Definition Classes
SeqLike → GenSeqLike
def reverseIterator: Iterator[Any]

Definition Classes
SeqLike
def reverseMap[B, That](f: (Any) ⇒ B)(implicit bf: CanBuildFrom[Message, B, That]): That

Definition Classes
SeqLike → GenSeqLike
def reversed: List[Any]

Attributes
protected[this]
Definition Classes
TraversableOnce
def runWith[U](action: (Any) ⇒ U): (Int) ⇒ Boolean

Definition Classes
PartialFunction
def sameElements[B >: Any](that: GenIterable[B]): Boolean

Definition Classes
IterableLike → GenIterableLike
def scan[B >: Any, That](z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Message, B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def scanLeft[B, That](z: B)(op: (B, Any) ⇒ B)(implicit bf: CanBuildFrom[Message, B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
def scanRight[B, That](z: B)(op: (Any, B) ⇒ B)(implicit bf: CanBuildFrom[Message, B, That]): That

Definition Classes
TraversableLike → GenTraversableLike
Annotations
@migration
Migration
(Changed in version 2.9.0) The behavior of scanRight has changed. The previous behavior can be reproduced with scanRight.reverse.
def segmentLength(p: (Any) ⇒ Boolean, from: Int): Int

Definition Classes
SeqLike → GenSeqLike
def seq: LinearSeq[Any]

Definition Classes
LinearSeq → LinearSeqLike → Seq → GenSeq → GenSeqLike → Iterable → GenIterable → Traversable → GenTraversable → Parallelizable → TraversableOnce → GenTraversableOnce
def size: Int

Definition Classes
SeqLike → GenTraversableLike → TraversableOnce → GenTraversableOnce
def slice(from: Int, until: Int): Message

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def sliding(size: Int, step: Int): Iterator[Message]

Definition Classes
IterableLike
def sliding(size: Int): Iterator[Message]

Definition Classes
IterableLike
def sortBy[B](f: (Any) ⇒ B)(implicit ord: Ordering[B]): Message

Definition Classes
SeqLike
def sortWith(lt: (Any, Any) ⇒ Boolean): Message

Definition Classes
SeqLike
def sorted[B >: Any](implicit ord: Ordering[B]): Message

Definition Classes
SeqLike
def span(p: (Any) ⇒ Boolean): (Message, Message)

Definition Classes
TraversableLike → GenTraversableLike
def splitAt(n: Int): (Message, Message)

Definition Classes
TraversableLike → GenTraversableLike
val startFrame: Int

the offset in frames into the audio-file to begin reading from
def startsWith[B](that: GenSeq[B], offset: Int): Boolean

Definition Classes
SeqLike → GenSeqLike
def startsWith[B](that: GenSeq[B]): Boolean

Definition Classes
GenSeqLike
def stringPrefix: String

Definition Classes
Message → TraversableLike → GenTraversableLike
def sum[B >: Any](implicit num: Numeric[B]): B

Definition Classes
TraversableOnce → GenTraversableOnce
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tail: Message

Definition Classes
TraversableLike → GenTraversableLike
def tails: Iterator[Message]

Definition Classes
TraversableLike
def take(n: Int): Message

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def takeRight(n: Int): Message

Definition Classes
IterableLike
def takeWhile(p: (Any) ⇒ Boolean): Message

Definition Classes
IterableLike → TraversableLike → GenTraversableLike
def thisCollection: LinearSeq[Any]

Attributes
protected[this]
Definition Classes
LinearSeqLike → SeqLike → IterableLike → TraversableLike
def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, Any, Col[Any]]): Col[Any]

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
def toArray[B >: Any](implicit arg0: ClassTag[B]): Array[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toBuffer[B >: Any]: scala.collection.mutable.Buffer[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toCollection(repr: Message): LinearSeq[Any]

Attributes
protected[this]
Definition Classes
LinearSeqLike → SeqLike → IterableLike → TraversableLike
def toIndexedSeq: IndexedSeq[Any]

Definition Classes
TraversableOnce → GenTraversableOnce
def toIterable: Iterable[Any]

Definition Classes
IterableLike → TraversableOnce → GenTraversableOnce
def toIterator: Iterator[Any]

Definition Classes
IterableLike → TraversableLike → GenTraversableOnce
Annotations
@deprecatedOverriding( ... , "2.11.0" )
def toList: List[Any]

Definition Classes
TraversableOnce → GenTraversableOnce
def toMap[T, U](implicit ev: <:<[Any, (T, U)]): Map[T, U]

Definition Classes
TraversableOnce → GenTraversableOnce
def toSeq: Seq[Any]

Definition Classes
SeqLike → GenSeqLike → TraversableOnce → GenTraversableOnce
def toSet[B >: Any]: Set[B]

Definition Classes
TraversableOnce → GenTraversableOnce
def toStream: Stream[Any]

Definition Classes
IterableLike → TraversableLike → GenTraversableOnce
def toString(): String

Definition Classes
Message → SeqLike → TraversableLike → Function1 → AnyRef → Any
def toTraversable: Traversable[Any]

Definition Classes
TraversableLike → TraversableOnce → GenTraversableOnce
Annotations
@deprecatedOverriding( ... , "2.11.0" )
def toVector: Vector[Any]

Definition Classes
TraversableOnce → GenTraversableOnce
def transpose[B](implicit asTraversable: (Any) ⇒ GenTraversableOnce[B]): LinearSeq[LinearSeq[B]]

Definition Classes
GenericTraversableTemplate
Annotations
@migration
Migration
(Changed in version 2.9.0) transpose throws an IllegalArgumentException if collections are not uniformly sized.
def union[B >: Any, That](that: GenSeq[B])(implicit bf: CanBuildFrom[Message, B, That]): That

Definition Classes
SeqLike → GenSeqLike
def unzip[A1, A2](implicit asPair: (Any) ⇒ (A1, A2)): (LinearSeq[A1], LinearSeq[A2])

Definition Classes
GenericTraversableTemplate
def unzip3[A1, A2, A3](implicit asTriple: (Any) ⇒ (A1, A2, A3)): (LinearSeq[A1], LinearSeq[A2], LinearSeq[A3])

Definition Classes
GenericTraversableTemplate
def updateCompletion(completion: Option[Packet]): BufferAllocReadChannel

Definition Classes
BufferAllocReadChannel → HasCompletion
def updated[B >: Any, That](index: Int, elem: B)(implicit bf: CanBuildFrom[Message, B, That]): That

Definition Classes
SeqLike → GenSeqLike
def view(from: Int, until: Int): SeqView[Any, Message]

Definition Classes
SeqLike → IterableLike → TraversableLike
def view: SeqView[Any, Message]

Definition Classes
SeqLike → IterableLike → TraversableLike
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( ... )
def withFilter(p: (Any) ⇒ Boolean): FilterMonadic[Any, Message]

Definition Classes
TraversableLike → FilterMonadic
def zip[A1 >: Any, B, That](that: GenIterable[B])(implicit bf: CanBuildFrom[Message, (A1, B), That]): That

Definition Classes
IterableLike → GenIterableLike
def zipAll[B, A1 >: Any, That](that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[Message, (A1, B), That]): That

Definition Classes
IterableLike → GenIterableLike
def zipWithIndex[A1 >: Any, That](implicit bf: CanBuildFrom[Message, (A1, Int), That]): That

Definition Classes
IterableLike → GenIterableLike

Related Doc: package message

final case class BufferAllocReadChannel(id: Int, path: String, startFrame: Int, numFrames: Int, channels: List[Int], completion: Option[Packet]) extends Message with HasCompletion with Product with Serializable

Instance Constructors

new BufferAllocReadChannel(id: Int, path: String, startFrame: Int, numFrames: Int, channels: List[Int], completion: Option[Packet])

Type Members

type Self = Message

class WithFilter extends FilterMonadic[A, Repr]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++[B >: Any, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Message, B, That]): That

def ++:[B >: Any, That](that: Traversable[B])(implicit bf: CanBuildFrom[Message, B, That]): That

def ++:[B >: Any, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Message, B, That]): That

def +:[B >: Any, That](elem: B)(implicit bf: CanBuildFrom[Message, B, That]): That

def /:[B](z: B)(op: (B, Any) ⇒ B): B

def :+[B >: Any, That](elem: B)(implicit bf: CanBuildFrom[Message, B, That]): That

def :\[B](z: B)(op: (Any, B) ⇒ B): B

final def ==(arg0: Any): Boolean

def addString(b: StringBuilder): StringBuilder

def addString(b: StringBuilder, sep: String): StringBuilder

def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

def aggregate[B](z: ⇒ B)(seqop: (B, Any) ⇒ B, combop: (B, B) ⇒ B): B

def andThen[C](k: (Any) ⇒ C): PartialFunction[Int, C]

def apply(idx: Int): Any

def applyOrElse[A1 <: Int, B1 >: Any](x: A1, default: (A1) ⇒ B1): B1

val args: Any*

final def asInstanceOf[T0]: T0

def canEqual(that: Any): Boolean

val channels: List[Int]

def clone(): AnyRef

def collect[B, That](pf: PartialFunction[Any, B])(implicit bf: CanBuildFrom[Message, B, That]): That

def collectFirst[B](pf: PartialFunction[Any, B]): Option[B]

def combinations(n: Int): Iterator[Message]

def companion: GenericCompanion[LinearSeq]

val completion: Option[Packet]

def compose[A](g: (A) ⇒ Int): (A) ⇒ Any

def contains[A1 >: Any](elem: A1): Boolean

def containsSlice[B](that: GenSeq[B]): Boolean

def copyToArray[B >: Any](xs: Array[B], start: Int, len: Int): Unit

def copyToArray[B >: Any](xs: Array[B]): Unit

def copyToArray[B >: Any](xs: Array[B], start: Int): Unit

def copyToBuffer[B >: Any](dest: scala.collection.mutable.Buffer[B]): Unit

final def corresponds[B](that: GenSeq[B])(p: (Any, B) ⇒ Boolean): Boolean

def count(p: (Any) ⇒ Boolean): Int

def diff[B >: Any](that: GenSeq[B]): Message

def distinct: Message

def drop(n: Int): Message

def dropRight(n: Int): Message

def dropWhile(p: (Any) ⇒ Boolean): Message

def encode(c: PacketCodec, b: ByteBuffer): Unit

def encodedSize(c: PacketCodec): Int

def endsWith[B](that: GenSeq[B]): Boolean

final def eq(arg0: AnyRef): Boolean

def equals(other: Any): Boolean

def exists(p: (Any) ⇒ Boolean): Boolean

def filter(p: (Any) ⇒ Boolean): Message

def filterNot(p: (Any) ⇒ Boolean): Message

def finalize(): Unit

def find(p: (Any) ⇒ Boolean): Option[Any]

def flatMap[B, That](f: (Any) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[Message, B, That]): That

def flatten[B](implicit asTraversable: (Any) ⇒ GenTraversableOnce[B]): LinearSeq[B]

def fold[A1 >: Any](z: A1)(op: (A1, A1) ⇒ A1): A1

def foldLeft[B](z: B)(op: (B, Any) ⇒ B): B

def foldRight[B](z: B)(op: (Any, B) ⇒ B): B

def forall(p: (Any) ⇒ Boolean): Boolean

def foreach[U](f: (Any) ⇒ U): Unit

def genericBuilder[B]: Builder[B, LinearSeq[B]]

final def getClass(): Class[_]

def groupBy[K](f: (Any) ⇒ K): Map[K, Message]

def grouped(size: Int): Iterator[Message]

def hasDefiniteSize: Boolean

def hashCode(): Int

def head: Any

def headOption: Option[Any]

val id: Int

def indexOf[B >: Any](elem: B, from: Int): Int

def indexOf[B >: Any](elem: B): Int

def indexOfSlice[B >: Any](that: GenSeq[B], from: Int): Int

def indexOfSlice[B >: Any](that: GenSeq[B]): Int