MappedManyToMany

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

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

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

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

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

def ++=(xs: TraversableOnce[T2]): MappedManyToMany.this.type

def ++=:(xs: TraversableOnce[T2]): MappedManyToMany.this.type

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

def +=(elem: T2): MappedManyToMany.this.type

def +=(elem1: T2, elem2: T2, elems: T2*): MappedManyToMany.this.type

def +=:(elem: T2): MappedManyToMany.this.type

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

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

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

def --=(xs: TraversableOnce[T2]): MappedManyToMany.this.type

def -=(x: T2): MappedManyToMany.this.type

def -=(elem1: T2, elem2: T2, elems: T2*): MappedManyToMany.this.type

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

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

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

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

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

var _joins: List[O]

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

def all: List[T2]

Get the List backing this Buffer.

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

def append(elems: T2*): Unit

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

def apply(n: Int): T2

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

final def asInstanceOf[T0]: T0

def canEqual(that: Any): Boolean

def childAt(n: Int): T2

def children: List[T2]

def clear(): Unit

def clone(): Buffer[T2]

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

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

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

def companion: GenericCompanion[Buffer]

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

def contains(elem: Any): Boolean

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

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

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

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

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

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

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

def delete_!: Boolean

Deletes all join rows, including those marked for removal.

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

def distinct: Buffer[T2]

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

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

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

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

final def eq(arg0: AnyRef): Boolean

def equals(that: Any): Boolean

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

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

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

def finalize(): Unit

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

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

def flatten[B](implicit asTraversable: (T2) ⇒ GenTraversableOnce[B]): Buffer[B]

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

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

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

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

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

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

final def getClass(): Class[_]

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

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

def hasDefiniteSize: Boolean

def hashCode(): Int

def head: T2

def headOption: Option[T2]

def indexOf(e: T2): Int

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

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

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

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

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

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

def indices: Range

def init: Buffer[T2]

def inits: Iterator[Buffer[T2]]

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

def insertAll(n: Int, traversable: Traversable[T2]): Unit

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

def isDefinedAt(idx: Int): Boolean

def isEmpty: Boolean

final def isInstanceOf[T0]: Boolean

def isJoinForChild(e: T2)(join: O): Boolean

final def isTraversableAgain: Boolean

def iterator: Iterator[T2]

def joinForChild(e: T2): Option[O]

val joinMeta: MetaMapper[O]

The singleton of the join table

def joins: List[O]

Get the list of instances of joinMeta

def last: T2

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

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

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

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

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

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

def lastOption: Option[T2]

def length: Int

def lengthCompare(len: Int): Int

def lift: (Int) ⇒ Option[T2]

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

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

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

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

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

def mkString: String

def mkString(sep: String): String

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

final def ne(arg0: AnyRef): Boolean

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

def nonEmpty: Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

def otherFK[A](join: O)(f: (MappedForeignKey[K2, O, T2]) ⇒ A): A

val otherField: MappedForeignKey[K2, O, T2]

The foreign key in the join table that refers to the other mapper's primaryKey

val otherMeta: MetaMapper[T2]

The singleton of the other mapper

def own(e: T2): O

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

def par: ParSeq[T2]

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

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

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

def permutations: Iterator[Buffer[T2]]

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

def prepend(elems: T2*): Unit

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

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

val qp: QueryParam[O]*

Any QueryParams to limit entries in the join table (other than matching thisField to primaryKey) To limit children based on fields in the other table (not the join table), it is currently necessary to point the join mapper to a view which pulls the join table's fields as well as fields of the other table.

def readOnly: Seq[T2]

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

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

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

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

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

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

def refresh: List[T2]

Discard the cached state of this MappedManyToMany's children and reinitialize it from the database

def remove(n: Int): T2

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

var removedJoins: List[O]

def repr: Buffer[T2]

def reverse: Buffer[T2]

def reverseIterator: Iterator[T2]

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

def reversed: List[T2]

def runWith[U](action: (T2) ⇒ U): (Int) ⇒ Boolean

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

def save: Boolean

Save the state of this MappedManyToMany to the database.

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

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

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

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

def seq: Seq[T2]

def size: Int

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

def sliding(size: Int, step: Int): Iterator[Buffer[T2]]

def sliding(size: Int): Iterator[Buffer[T2]]

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

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

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

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

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

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

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

def stringPrefix: String

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

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

def tail: Buffer[T2]

def tails: Iterator[Buffer[T2]]

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

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

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

def thisCollection: Seq[T2]

def to[Col[_]](implicit cbf: CanBuildFrom[Nothing, T2, Col[T2]]): Col[T2]

def toArray[B >: T2](implicit arg0: ClassTag[B]): Array[B]

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

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

def toIndexedSeq: IndexedSeq[T2]

def toIterable: Iterable[T2]

def toIterator: Iterator[T2]

def toList: List[T2]

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

def toSeq: Seq[T2]

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

def toStream: Stream[T2]

def toString(): String

def toTraversable: Traversable[T2]

def toVector: Vector[T2]

def transform(f: (T2) ⇒ T2): MappedManyToMany.this.type

def transpose[B](implicit asTraversable: (T2) ⇒ GenTraversableOnce[B]): Buffer[Buffer[B]]

def trimEnd(n: Int): Unit

def trimStart(n: Int): Unit

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

def unown(e: T2): Option[O]

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

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

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

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

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

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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

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

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

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

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