Instance Constructors
-
new
TableFor16
(heading: (String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String), rows: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)*)
Type Members
-
type
Self
= TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]
Value Members
-
def
!=
(arg0: AnyRef): Boolean
-
def
!=
(arg0: Any): Boolean
-
def
##
(): Int
-
def
++
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), That]
(that: TraversableOnce[B])(implicit bf: CanBuildFrom[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], B, That]): That
-
def
++
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), That]
(that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], B, That]): That
-
def
++:
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), That]
(that: Traversable[B])(implicit bf: CanBuildFrom[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], B, That]): That
-
def
++:
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), That]
(that: TraversableOnce[B])(implicit bf: CanBuildFrom[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], B, That]): That
-
def
+:
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), That]
(elem: B)(implicit bf: CanBuildFrom[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], B, That]): That
-
def
/:
[B]
(z: B)(op: (B, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ B): B
-
def
/:\
[A1 >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(z: A1)(op: (A1, A1) ⇒ A1): A1
-
def
:+
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), That]
(elem: B)(implicit bf: CanBuildFrom[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], B, That]): That
-
def
:\
[B]
(z: B)(op: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), B) ⇒ B): B
-
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, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ B, combop: (B, B) ⇒ B): B
-
def
andThen
[C]
(k: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ C): PartialFunction[Int, C]
-
def
apply
(fun: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) ⇒ Unit): Unit
-
def
apply
(idx: Int): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
-
def
asInstanceOf
[T0]
: T0
-
def
canEqual
(that: Any): Boolean
-
def
clone
(): AnyRef
-
def
collect
[B, That]
(pf: PartialFunction[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), B])(implicit bf: CanBuildFrom[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], B, That]): That
-
def
collectFirst
[B]
(pf: PartialFunction[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), B]): Option[B]
-
def
combinations
(n: Int): Iterator[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]]
-
def
companion
: GenericCompanion[IndexedSeq]
-
def
compose
[A]
(g: (A) ⇒ Int): (A) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
-
def
contains
(elem: Any): Boolean
-
def
containsSlice
[B]
(that: Seq[B]): Boolean
-
def
containsSlice
[B]
(that: GenSeq[B]): Boolean
-
def
copyToArray
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(xs: Array[B], start: Int, len: Int): Unit
-
def
copyToArray
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(xs: Array[B]): Unit
-
def
copyToArray
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(xs: Array[B], start: Int): Unit
-
def
copyToBuffer
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(dest: Buffer[B]): Unit
-
def
corresponds
[B]
(that: Seq[B])(p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), B) ⇒ Boolean): Boolean
-
def
corresponds
[B]
(that: GenSeq[B])(p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), B) ⇒ Boolean): Boolean
-
def
count
(p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ Boolean): Int
-
def
diff
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(that: Seq[B]): TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]
-
def
diff
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(that: GenSeq[B]): TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]
-
def
distinct
: TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]
-
def
drop
(n: Int): TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]
-
def
dropRight
(n: Int): TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]
-
def
dropWhile
(p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ Boolean): TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]
-
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: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ Boolean): Boolean
-
def
filter
(p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ Boolean): TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]
-
def
filterNot
(p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ Boolean): TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]
-
def
finalize
(): Unit
-
def
find
(p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ Boolean): Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
-
def
flatMap
[B, That]
(f: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ GenTraversableOnce[B])(implicit bf: CanBuildFrom[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], B, That]): That
-
def
flatten
[B]
(implicit asTraversable: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ TraversableOnce[B]): Traversable[B]
-
def
fold
[A1 >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(z: A1)(op: (A1, A1) ⇒ A1): A1
-
def
foldLeft
[B]
(z: B)(op: (B, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ B): B
-
def
foldRight
[B]
(z: B)(op: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), B) ⇒ B): B
-
def
forall
(p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ Boolean): Boolean
-
def
foreach
[U]
(f: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ U): Unit
-
def
genericBuilder
[B]
: Builder[B, IndexedSeq[B]]
-
def
getClass
(): java.lang.Class[_]
-
def
groupBy
[K]
(f: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ K): Map[K, TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]]
-
def
grouped
(size: Int): Iterator[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]]
-
def
hasDefiniteSize
: Boolean
-
def
hashCode
(): Int
-
def
head
: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
-
def
headOption
: Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
-
val
heading
: (String, String, String, String, String, String, String, String, String, String, String, String, String, String, String, String)
-
def
indexOf
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(elem: B, from: Int): Int
-
def
indexOf
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(elem: B): Int
-
def
indexOfSlice
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(that: Seq[B], from: Int): Int
-
def
indexOfSlice
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(that: GenSeq[B], from: Int): Int
-
def
indexOfSlice
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(that: Seq[B]): Int
-
def
indexOfSlice
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(that: GenSeq[B]): Int
-
def
indexWhere
(p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ Boolean, from: Int): Int
-
def
indexWhere
(p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ Boolean): Int
-
def
indices
: Range
-
def
init
: TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]
-
def
inits
: Iterator[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]]
-
def
intersect
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(that: Seq[B]): TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]
-
def
intersect
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(that: GenSeq[B]): TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]
-
def
isDefinedAt
(idx: Int): Boolean
-
def
isEmpty
: Boolean
-
def
isInstanceOf
[T0]
: Boolean
-
def
isTraversableAgain
: Boolean
-
def
iterator
: Iterator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
-
def
last
: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
-
def
lastIndexOf
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(elem: B, end: Int): Int
-
def
lastIndexOf
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(elem: B): Int
-
def
lastIndexOfSlice
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(that: Seq[B], end: Int): Int
-
def
lastIndexOfSlice
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(that: GenSeq[B], end: Int): Int
-
def
lastIndexOfSlice
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(that: Seq[B]): Int
-
def
lastIndexOfSlice
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(that: GenSeq[B]): Int
-
def
lastIndexWhere
(p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ Boolean, end: Int): Int
-
def
lastIndexWhere
(p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ Boolean): Int
-
def
lastOption
: Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
-
def
length
: Int
-
def
lengthCompare
(len: Int): Int
-
def
lift
: (Int) ⇒ Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
-
def
map
[B, That]
(f: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ B)(implicit bf: CanBuildFrom[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], B, That]): That
-
def
max
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(implicit cmp: Ordering[B]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
-
def
maxBy
[B]
(f: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ B)(implicit cmp: Ordering[B]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
-
def
min
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(implicit cmp: Ordering[B]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
-
def
minBy
[B]
(f: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ B)(implicit cmp: Ordering[B]): (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
-
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[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]]
-
def
nonEmpty
: Boolean
-
def
notify
(): Unit
-
def
notifyAll
(): Unit
-
def
orElse
[A1 <: Int, B1 >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(that: PartialFunction[A1, B1]): PartialFunction[A1, B1]
-
def
padTo
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), That]
(len: Int, elem: B)(implicit bf: CanBuildFrom[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], B, That]): That
-
def
par
: ParSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
-
def
parCombiner
: Combiner[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), ParSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]]
-
def
partition
(p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ Boolean): (TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P])
-
def
patch
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), That]
(from: Int, patch: Seq[B], replaced: Int)(implicit bf: CanBuildFrom[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], B, That]): That
-
def
patch
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), That]
(from: Int, patch: GenSeq[B], replaced: Int)(implicit bf: CanBuildFrom[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], B, That]): That
-
def
permutations
: Iterator[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]]
-
def
prefixLength
(p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ Boolean): Int
-
def
product
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(implicit num: Numeric[B]): B
-
def
reduce
[A1 >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(op: (A1, A1) ⇒ A1): A1
-
def
reduceLeft
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(op: (B, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ B): B
-
def
reduceLeftOption
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(op: (B, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ B): Option[B]
-
def
reduceOption
[A1 >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(op: (A1, A1) ⇒ A1): Option[A1]
-
def
reduceRight
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(op: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), B) ⇒ B): B
-
def
reduceRightOption
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(op: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), B) ⇒ B): Option[B]
-
def
repr
: TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]
-
def
reverse
: TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]
-
def
reverseIterator
: Iterator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
-
def
reverseMap
[B, That]
(f: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ B)(implicit bf: CanBuildFrom[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], B, That]): That
-
def
reversed
: List[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
-
def
sameElements
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(that: Iterable[B]): Boolean
-
def
sameElements
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(that: GenIterable[B]): Boolean
-
def
scan
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), That]
(z: B)(op: (B, B) ⇒ B)(implicit cbf: CanBuildFrom[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], B, That]): That
-
def
scanLeft
[B, That]
(z: B)(op: (B, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ B)(implicit bf: CanBuildFrom[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], B, That]): That
-
def
scanRight
[B, That]
(z: B)(op: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), B) ⇒ B)(implicit bf: CanBuildFrom[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], B, That]): That
-
def
segmentLength
(p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ Boolean, from: Int): Int
-
def
seq
: Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
-
def
size
: Int
-
def
slice
(from: Int, until: Int): TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]
-
def
sliding
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(size: Int, step: Int): Iterator[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]]
-
def
sliding
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(size: Int): Iterator[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]]
-
def
sortBy
[B]
(f: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ B)(implicit ord: Ordering[B]): TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]
-
def
sortWith
(lt: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ Boolean): TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]
-
def
sorted
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(implicit ord: Ordering[B]): TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]
-
def
span
(p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ Boolean): (TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P])
-
def
splitAt
(n: Int): (TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P])
-
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 >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(implicit num: Numeric[B]): B
-
def
synchronized
[T0]
(arg0: ⇒ T0): T0
-
def
tail
: TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]
-
def
tails
: Iterator[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]]
-
def
take
(n: Int): TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]
-
def
takeRight
(n: Int): TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]
-
def
takeWhile
(p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ Boolean): TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]
-
def
thisCollection
: IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
-
def
toArray
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
(implicit arg0: ClassManifest[B]): Array[B]
-
def
toBuffer
[A1 >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
: Buffer[A1]
-
def
toCollection
(repr: TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]): IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
-
def
toIndexedSeq
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
: IndexedSeq[B]
-
def
toIterable
: Iterable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
-
def
toIterator
: Iterator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
-
def
toList
: List[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
-
def
toMap
[T, U]
(implicit ev: <:<[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), (T, U)]): Map[T, U]
-
def
toSeq
: Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
-
def
toSet
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
: Set[B]
-
def
toStream
: Stream[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
-
def
toString
(): String
-
def
toTraversable
: Traversable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
-
def
transpose
[B]
(implicit asTraversable: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ TraversableOnce[B]): Traversable[Traversable[B]]
-
def
union
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), That]
(that: GenSeq[B])(implicit bf: CanBuildFrom[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], B, That]): That
-
def
union
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), That]
(that: Seq[B])(implicit bf: CanBuildFrom[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], B, That]): That
-
def
unzip
[A1, A2]
(implicit asPair: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ (A1, A2)): (IndexedSeq[A1], IndexedSeq[A2])
-
def
unzip3
[A1, A2, A3]
(implicit asTriple: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ (A1, A2, A3)): (IndexedSeq[A1], IndexedSeq[A2], IndexedSeq[A3])
-
def
updated
[B >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), That]
(index: Int, elem: B)(implicit bf: CanBuildFrom[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], B, That]): That
-
def
view
(from: Int, until: Int): SeqView[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]]
-
def
view
: SeqView[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]]
-
def
wait
(): Unit
-
def
wait
(arg0: Long, arg1: Int): Unit
-
def
wait
(arg0: Long): Unit
-
def
withFilter
(p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ Boolean): FilterMonadic[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]]
-
def
zip
[A1 >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), B, That]
(that: Iterable[B])(implicit bf: CanBuildFrom[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], (A1, B), That]): That
-
def
zip
[A1 >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), B, That]
(that: GenIterable[B])(implicit bf: CanBuildFrom[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], (A1, B), That]): That
-
def
zipAll
[B, A1 >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), That]
(that: Iterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], (A1, B), That]): That
-
def
zipAll
[B, A1 >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), That]
(that: GenIterable[B], thisElem: A1, thatElem: B)(implicit bf: CanBuildFrom[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], (A1, B), That]): That
-
def
zipWithIndex
[A1 >: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), That]
(implicit bf: CanBuildFrom[TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P], (A1, Int), That]): That
-
def
elements
: Iterator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
-
def
equalsWith
[B]
(that: Seq[B])(f: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), B) ⇒ Boolean): Boolean
-
def
findIndexOf
(p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ Boolean): Int
-
def
findLastIndexOf
(p: ((A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) ⇒ Boolean): Int
-
def
first
: (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
-
def
firstOption
: Option[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
-
def
projection
: SeqView[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]]
-
def
reversedElements
: Iterator[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
Inherited from IndexedSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
Inherited from IndexedSeqLike[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]]
Inherited from Seq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
Inherited from SeqLike[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]]
Inherited from GenSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
Inherited from GenSeqLike[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]]
Inherited from Iterable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
Inherited from IterableLike[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]]
Inherited from Equals
Inherited from GenIterable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
Inherited from GenIterableLike[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]]
Inherited from Traversable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
Inherited from GenTraversable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
Inherited from GenericTraversableTemplate[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), IndexedSeq]
Inherited from TraversableLike[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]]
Inherited from GenTraversableLike[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]]
Inherited from Parallelizable[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), ParSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]]
Inherited from TraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
Inherited from GenTraversableOnce[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
Inherited from FilterMonadic[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]]
Inherited from HasNewBuilder[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), TableFor16[A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P]]
Inherited from PartialFunction[Int, (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
Inherited from (Int) ⇒ (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)
Inherited from AnyRef
Inherited from Any
A table with 16 columns.
For an introduction to using tables, see the documentation for trait TableDrivenPropertyChecks.
This table is a sequence of
Tuple16
objects, where each tuple represents one row of the table. The first element of each tuple comprise the first column of the table, the second element of each tuple comprise the second column, and so on. This table also carries with it a heading tuple that gives string names to the columns of the table.A handy way to create a
TableFor16
is via anapply
factory method in theTable
singleton object provided by theTables
trait. Here's an example:Because you supplied 16 members in each tuple, the type you'll get back will be a
TableFor16
.The table provides an
apply
method that takes a function with a parameter list that matches the types and arity of the tuples contained in this table. Theapply
method will invoke the function with the members of each row tuple passed as arguments, in ascending order by index. (I.e., the zeroth tuple is checked first, then the tuple with index 1, then index 2, and so on until all the rows have been checked (or until a failure occurs). The function represents a property of the code under test that should succeed for every row of the table. If the function returns normally, that indicates the property check succeeded for that row. If the function completes abruptly with an exception, that indicates the property check failed and theapply
method will complete abruptly with aTableDrivenPropertyCheckFailedException
that wraps the exception thrown by the supplied property function.The usual way you'd invoke the
apply
method that checks a property is via aforAll
method provided by traitTableDrivenPropertyChecks
. TheforAll
method takes aTableFor16
as its first argument, then in a curried argument list takes the property check function. It invokesapply
on theTableFor16
, passing in the property check function. Here's an example:forAll (examples) { (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p) => a + b + c + d + e + f + g + h + i + j + k + l + m + n + o + p should equal (a * 16) }
Because
TableFor16
is aSeq[(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)]
, you can use it as aSeq
. For example, here's how you could get a sequence of optional exceptions for each row of the table, indicating whether a property check succeeded or failed on each row of the table:Note: the
failureOf
method, contained in theFailureOf
trait, will execute the supplied code (a by-name parameter) and catch any exception. If no exception is thrown by the code,failureOf
will result inNone
, indicating the "property check" succeeded. If the supplied code completes abruptly in an exception that would normally cause a test to fail,failureOf
will result in aSome
wrapping that exception. For example, the previous for expression would give you:This shows that all the property checks succeeded, except for the one at index 7.