MappedOneToMany

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def ++ (xs: TraversableOnce[O]): Buffer[O]

def ++ (xs: GenTraversableOnce[O]): Buffer[O]

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

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

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

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

def ++= (xs: TraversableOnce[O]): MappedOneToMany.this.type

def ++=: (xs: TraversableOnce[O]): MappedOneToMany.this.type

def +: [B >: O, That] (elem: B)(implicit bf: CanBuildFrom[Buffer[O], B, That]): That

def += (elem: O): MappedOneToMany.this.type

def += (elem1: O, elem2: O, elems: O*): MappedOneToMany.this.type

def +=: (elem: O): MappedOneToMany.this.type

def - (elem1: O, elem2: O, elems: O*): Buffer[O]

def - (elem: O): Buffer[O]

def -- (xs: TraversableOnce[O]): Buffer[O]

def -- (xs: GenTraversableOnce[O]): Buffer[O]

def --= (xs: TraversableOnce[O]): MappedOneToMany.this.type

def -= (x: O): MappedOneToMany.this.type

def -= (elem1: O, elem2: O, elems: O*): MappedOneToMany.this.type

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

def /:\ [A1 >: O] (z: A1)(op: (A1, A1) ⇒ A1): A1

def :+ [B >: O, That] (elem: B)(implicit bf: CanBuildFrom[Buffer[O], B, That]): That

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

def << (cmd: Message[O]): Unit

def == (arg0: AnyRef): Boolean

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, O) ⇒ B, combop: (B, B) ⇒ B): B

def all : List[O]

Returns the backing List

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

def append (elems: O*): Unit

def appendAll (xs: TraversableOnce[O]): Unit

def apply (n: Int): O

def asInstanceOf [T0] : T0

def canEqual (that: Any): Boolean

def clear (): Unit

def clone (): Buffer[O]

def collect [B, That] (pf: PartialFunction[O, B])(implicit bf: CanBuildFrom[Buffer[O], B, That]): That

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

def combinations (n: Int): Iterator[Buffer[O]]

def companion : GenericCompanion[Buffer]

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

def contains (elem: Any): Boolean

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

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

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

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

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

def copyToBuffer [B >: O] (dest: Buffer[B]): Unit

def corresponds [B] (that: Seq[B])(p: (O, B) ⇒ Boolean): Boolean

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

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

def delegate : List[O]

def delegate_= (d: List[O]): Unit

def diff [B >: O] (that: Seq[B]): Buffer[O]

def diff [B >: O] (that: GenSeq[B]): Buffer[O]

def distinct : Buffer[O]

def drop (n: Int): Buffer[O]

def dropRight (n: Int): Buffer[O]

def dropWhile (p: (O) ⇒ Boolean): Buffer[O]

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

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

def eq (arg0: AnyRef): Boolean

def equals (that: Any): Boolean

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

def filter (p: (O) ⇒ Boolean): Buffer[O]

def filterNot (p: (O) ⇒ Boolean): Buffer[O]

def finalize (): Unit

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

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

def flatten [B] (implicit asTraversable: (O) ⇒ TraversableOnce[B]): Traversable[B]

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

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

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

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

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

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

def getClass (): java.lang.Class[_]

def groupBy [K] (f: (O) ⇒ K): Map[K, Buffer[O]]

def grouped (size: Int): Iterator[Buffer[O]]

def hasDefiniteSize : Boolean

def hashCode (): Int

def head : O

def headOption : Option[O]

def indexOf [B >: O] (e: B): Int

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

def indexOfSlice [B >: O] (that: Seq[B], from: Int): Int

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

def indexOfSlice [B >: O] (that: Seq[B]): Int

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

def indexWhere (p: (O) ⇒ Boolean, from: Int): Int

def indexWhere (p: (O) ⇒ Boolean): Int

def indices : Range

def init : Buffer[O]

def inits : Iterator[Buffer[O]]

def insert (n: Int, elems: O*): Unit

def insertAll (n: Int, iter: Traversable[O]): Unit

def intersect [B >: O] (that: Seq[B]): Buffer[O]

def intersect [B >: O] (that: GenSeq[B]): Buffer[O]

def isDefinedAt (idx: Int): Boolean

def isEmpty : Boolean

def isInstanceOf [T0] : Boolean

def isTraversableAgain : Boolean

def iterator : Iterator[O]

def last : O

def lastIndexOf [B >: O] (elem: B, end: Int): Int

def lastIndexOf [B >: O] (elem: B): Int

def lastIndexOfSlice [B >: O] (that: Seq[B], end: Int): Int

def lastIndexOfSlice [B >: O] (that: GenSeq[B], end: Int): Int

def lastIndexOfSlice [B >: O] (that: Seq[B]): Int

def lastIndexOfSlice [B >: O] (that: GenSeq[B]): Int

def lastIndexWhere (p: (O) ⇒ Boolean, end: Int): Int

def lastIndexWhere (p: (O) ⇒ Boolean): Int

def lastOption : Option[O]

def length : Int

def lengthCompare (len: Int): Int

def lift : (Int) ⇒ Option[O]

def map [B, That] (f: (O) ⇒ B)(implicit bf: CanBuildFrom[Buffer[O], B, That]): That

def max [B >: O] (implicit cmp: Ordering[B]): O

def maxBy [B] (f: (O) ⇒ B)(implicit cmp: Ordering[B]): O

def min [B >: O] (implicit cmp: Ordering[B]): O

def minBy [B] (f: (O) ⇒ B)(implicit cmp: Ordering[B]): O

def mkString : String

def mkString (sep: String): String

def mkString (start: String, sep: String, end: String): String

def ne (arg0: AnyRef): Boolean

def newBuilder : Builder[O, Buffer[O]]

def nonEmpty : Boolean

def notify (): Unit

def notifyAll (): Unit

def orElse [A1 <: Int, B1 >: O] (that: PartialFunction[A1, B1]): PartialFunction[A1, B1]

def own (e: O): O

Takes ownership of e.

def padTo [B >: O, That] (len: Int, elem: B)(implicit bf: CanBuildFrom[Buffer[O], B, That]): That

def par : ParSeq[O]

def parCombiner : Combiner[O, ParSeq[O]]

def partition (p: (O) ⇒ Boolean): (Buffer[O], Buffer[O])

def patch [B >: O, That] (from: Int, patch: Seq[B], replaced: Int)(implicit bf: CanBuildFrom[Buffer[O], B, That]): That

def patch [B >: O, That] (from: Int, patch: GenSeq[B], replaced: Int)(implicit bf: CanBuildFrom[Buffer[O], B, That]): That

def permutations : Iterator[Buffer[O]]

def prefixLength (p: (O) ⇒ Boolean): Int

def prepend (elems: O*): Unit

def prependAll (xs: TraversableOnce[O]): Unit

def product [B >: O] (implicit num: Numeric[B]): B

def readOnly : Seq[O]

def reduce [A1 >: O] (op: (A1, A1) ⇒ A1): A1

def reduceLeft [B >: O] (op: (B, O) ⇒ B): B

def reduceLeftOption [B >: O] (op: (B, O) ⇒ B): Option[B]

def reduceOption [A1 >: O] (op: (A1, A1) ⇒ A1): Option[A1]

def reduceRight [B >: O] (op: (O, B) ⇒ B): B

def reduceRightOption [B >: O] (op: (O, B) ⇒ B): Option[B]

def refresh : Unit

Reloads the children from storage.

val reloadFunc : () ⇒ Seq[O]

def remove (n: Int): O

def remove (n: Int, count: Int): Unit

def repr : Buffer[O]

def reverse : Buffer[O]

def reverseIterator : Iterator[O]

def reverseMap [B, That] (f: (O) ⇒ B)(implicit bf: CanBuildFrom[Buffer[O], B, That]): That

def reversed : List[O]

def sameElements [B >: O] (that: Iterable[B]): Boolean

def sameElements [B >: O] (that: GenIterable[B]): Boolean

def save : Boolean

Saves this "field," i.

def scan [B >: O, That] (z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[Buffer[O], B, That]): That

def scanLeft [B, That] (z: B)(op: (B, O) ⇒ B)(implicit bf: CanBuildFrom[Buffer[O], B, That]): That

def scanRight [B, That] (z: B)(op: (O, B) ⇒ B)(implicit bf: CanBuildFrom[Buffer[O], B, That]): That

def segmentLength (p: (O) ⇒ Boolean, from: Int): Int

def seq : Seq[O]

def size : Int

def slice (from: Int, until: Int): Buffer[O]

def sliding [B >: O] (size: Int, step: Int): Iterator[Buffer[O]]

def sliding [B >: O] (size: Int): Iterator[Buffer[O]]

def sortBy [B] (f: (O) ⇒ B)(implicit ord: Ordering[B]): Buffer[O]

def sortWith (lt: (O, O) ⇒ Boolean): Buffer[O]

def sorted [B >: O] (implicit ord: Ordering[B]): Buffer[O]

def span (p: (O) ⇒ Boolean): (Buffer[O], Buffer[O])

def splitAt (n: Int): (Buffer[O], Buffer[O])

def startsWith [B] (that: Seq[B], offset: Int): Boolean

def startsWith [B] (that: GenSeq[B], offset: Int): Boolean

def startsWith [B] (that: Seq[B]): Boolean

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

def stringPrefix : String

def sum [B >: O] (implicit num: Numeric[B]): B

def synchronized [T0] (arg0: ⇒ T0): T0

def tail : Buffer[O]

def tails : Iterator[Buffer[O]]

def take (n: Int): Buffer[O]

def takeRight (n: Int): Buffer[O]

def takeWhile (p: (O) ⇒ Boolean): Buffer[O]

def thisCollection : Seq[O]

def toArray [B >: O] (implicit arg0: ClassManifest[B]): Array[B]

def toBuffer [B >: O] : Buffer[B]

def toCollection (repr: Buffer[O]): Seq[O]

def toIndexedSeq [B >: O] : IndexedSeq[B]

def toIterable : Iterable[O]

def toIterator : Iterator[O]

def toList : List[O]

def toMap [T, U] (implicit ev: <:<[O, (T, U)]): Map[T, U]

def toSeq : Seq[O]

def toSet [B >: O] : Set[B]

def toStream : Stream[O]

def toString (): String

def toTraversable : Traversable[O]

def transform (f: (O) ⇒ O): MappedOneToMany.this.type

def transpose [B] (implicit asTraversable: (O) ⇒ TraversableOnce[B]): Traversable[Traversable[B]]

def trimEnd (n: Int): Unit

def trimStart (n: Int): Unit

def union [B >: O, That] (that: GenSeq[B])(implicit bf: CanBuildFrom[Buffer[O], B, That]): That

def union [B >: O, That] (that: Seq[B])(implicit bf: CanBuildFrom[Buffer[O], B, That]): That

def unown (e: O): O

Relinquishes ownership of e.

def unzip [A1, A2] (implicit asPair: (O) ⇒ (A1, A2)): (Buffer[A1], Buffer[A2])

def unzip3 [A1, A2, A3] (implicit asTriple: (O) ⇒ (A1, A2, A3)): (Buffer[A1], Buffer[A2], Buffer[A3])

def update (n: Int, newelem: O): Unit

def updated [B >: O, That] (index: Int, elem: B)(implicit bf: CanBuildFrom[Buffer[O], B, That]): That

def view (from: Int, until: Int): SeqView[O, Buffer[O]]

def view : SeqView[O, Buffer[O]]

def wait (): Unit

def wait (arg0: Long, arg1: Int): Unit

def wait (arg0: Long): Unit

def withFilter (p: (O) ⇒ Boolean): FilterMonadic[O, Buffer[O]]

def zip [A1 >: O, B, That] (that: Iterable[B])(implicit bf: CanBuildFrom[Buffer[O], (A1, B), That]): That

def zip [A1 >: O, B, That] (that: GenIterable[B])(implicit bf: CanBuildFrom[Buffer[O], (A1, B), That]): That

def zipAll [B, A1 >: O, That] (that: Iterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[Buffer[O], (A1, B), That]): That

def zipAll [B, A1 >: O, That] (that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[Buffer[O], (A1, B), That]): That

def zipWithIndex [A1 >: O, That] (implicit bf: CanBuildFrom[Buffer[O], (A1, Int), That]): That

def + (elem1: O, elem2: O, elems: O*): Buffer[O]

def + (elem: O): Buffer[O]

def ++= (src: Array[O], start: Int, len: Int): Unit

def elements : Iterator[O]

def equalsWith [B] (that: Seq[B])(f: (O, B) ⇒ Boolean): Boolean

def findIndexOf (p: (O) ⇒ Boolean): Int

def findLastIndexOf (p: (O) ⇒ Boolean): Int

def first : O

def firstOption : Option[O]

def projection : SeqView[O, Buffer[O]]

def reversedElements : Iterator[O]