RowEncoder

Value Members

final def !=(arg0: Any): Boolean

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

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

Definition Classes
AnyRef → Any
def apply[A](f: (A) ⇒ Seq[String]): RowEncoder[A]

Creates a new RowEncoder using the specified function for encoding.
def apply[A](implicit ea: RowEncoder[A]): RowEncoder[A]

Summons an implicit instance of RowEncoder for the desired type if one can be found.
Summons an implicit instance of RowEncoder for the desired type if one can be found.
This is essentially a shorter way of calling implicitly[RowEncoder[A]].
final def asInstanceOf[T0]: T0

Definition Classes
Any
def caseEncoder1[C, A1](f: (C) ⇒ Option[A1])(implicit arg0: CellEncoder[A1]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseEncoder1 to call get on the return value.

Definition Classes
GeneratedRowEncoders
def caseEncoder10[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)])(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int)(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9], arg9: CellEncoder[A10]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseEncoder10 to call get on the return value.
f
encoding method, intended to be a case class' unapply method.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f
i10
index of the cell that should be passed as parameter number 10 of f

Definition Classes
GeneratedRowEncoders
def caseEncoder11[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)])(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int)(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9], arg9: CellEncoder[A10], arg10: CellEncoder[A11]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseEncoder11 to call get on the return value.
f
encoding method, intended to be a case class' unapply method.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f
i10
index of the cell that should be passed as parameter number 10 of f
i11
index of the cell that should be passed as parameter number 11 of f

Definition Classes
GeneratedRowEncoders
def caseEncoder12[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)])(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int, i12: Int)(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9], arg9: CellEncoder[A10], arg10: CellEncoder[A11], arg11: CellEncoder[A12]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseEncoder12 to call get on the return value.
f
encoding method, intended to be a case class' unapply method.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f
i10
index of the cell that should be passed as parameter number 10 of f
i11
index of the cell that should be passed as parameter number 11 of f
i12
index of the cell that should be passed as parameter number 12 of f

Definition Classes
GeneratedRowEncoders
def caseEncoder13[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)])(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int, i12: Int, i13: Int)(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9], arg9: CellEncoder[A10], arg10: CellEncoder[A11], arg11: CellEncoder[A12], arg12: CellEncoder[A13]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseEncoder13 to call get on the return value.
f
encoding method, intended to be a case class' unapply method.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f
i10
index of the cell that should be passed as parameter number 10 of f
i11
index of the cell that should be passed as parameter number 11 of f
i12
index of the cell that should be passed as parameter number 12 of f
i13
index of the cell that should be passed as parameter number 13 of f

Definition Classes
GeneratedRowEncoders
def caseEncoder14[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)])(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int, i12: Int, i13: Int, i14: Int)(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9], arg9: CellEncoder[A10], arg10: CellEncoder[A11], arg11: CellEncoder[A12], arg12: CellEncoder[A13], arg13: CellEncoder[A14]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseEncoder14 to call get on the return value.
f
encoding method, intended to be a case class' unapply method.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f
i10
index of the cell that should be passed as parameter number 10 of f
i11
index of the cell that should be passed as parameter number 11 of f
i12
index of the cell that should be passed as parameter number 12 of f
i13
index of the cell that should be passed as parameter number 13 of f
i14
index of the cell that should be passed as parameter number 14 of f

Definition Classes
GeneratedRowEncoders
def caseEncoder15[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)])(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int, i12: Int, i13: Int, i14: Int, i15: Int)(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9], arg9: CellEncoder[A10], arg10: CellEncoder[A11], arg11: CellEncoder[A12], arg12: CellEncoder[A13], arg13: CellEncoder[A14], arg14: CellEncoder[A15]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseEncoder15 to call get on the return value.
f
encoding method, intended to be a case class' unapply method.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f
i10
index of the cell that should be passed as parameter number 10 of f
i11
index of the cell that should be passed as parameter number 11 of f
i12
index of the cell that should be passed as parameter number 12 of f
i13
index of the cell that should be passed as parameter number 13 of f
i14
index of the cell that should be passed as parameter number 14 of f
i15
index of the cell that should be passed as parameter number 15 of f

Definition Classes
GeneratedRowEncoders
def caseEncoder16[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)])(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int, i12: Int, i13: Int, i14: Int, i15: Int, i16: Int)(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9], arg9: CellEncoder[A10], arg10: CellEncoder[A11], arg11: CellEncoder[A12], arg12: CellEncoder[A13], arg13: CellEncoder[A14], arg14: CellEncoder[A15], arg15: CellEncoder[A16]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseEncoder16 to call get on the return value.
f
encoding method, intended to be a case class' unapply method.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f
i10
index of the cell that should be passed as parameter number 10 of f
i11
index of the cell that should be passed as parameter number 11 of f
i12
index of the cell that should be passed as parameter number 12 of f
i13
index of the cell that should be passed as parameter number 13 of f
i14
index of the cell that should be passed as parameter number 14 of f
i15
index of the cell that should be passed as parameter number 15 of f
i16
index of the cell that should be passed as parameter number 16 of f

Definition Classes
GeneratedRowEncoders
def caseEncoder17[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)])(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int, i12: Int, i13: Int, i14: Int, i15: Int, i16: Int, i17: Int)(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9], arg9: CellEncoder[A10], arg10: CellEncoder[A11], arg11: CellEncoder[A12], arg12: CellEncoder[A13], arg13: CellEncoder[A14], arg14: CellEncoder[A15], arg15: CellEncoder[A16], arg16: CellEncoder[A17]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseEncoder17 to call get on the return value.
f
encoding method, intended to be a case class' unapply method.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f
i10
index of the cell that should be passed as parameter number 10 of f
i11
index of the cell that should be passed as parameter number 11 of f
i12
index of the cell that should be passed as parameter number 12 of f
i13
index of the cell that should be passed as parameter number 13 of f
i14
index of the cell that should be passed as parameter number 14 of f
i15
index of the cell that should be passed as parameter number 15 of f
i16
index of the cell that should be passed as parameter number 16 of f
i17
index of the cell that should be passed as parameter number 17 of f

Definition Classes
GeneratedRowEncoders
def caseEncoder18[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)])(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int, i12: Int, i13: Int, i14: Int, i15: Int, i16: Int, i17: Int, i18: Int)(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9], arg9: CellEncoder[A10], arg10: CellEncoder[A11], arg11: CellEncoder[A12], arg12: CellEncoder[A13], arg13: CellEncoder[A14], arg14: CellEncoder[A15], arg15: CellEncoder[A16], arg16: CellEncoder[A17], arg17: CellEncoder[A18]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseEncoder18 to call get on the return value.
f
encoding method, intended to be a case class' unapply method.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f
i10
index of the cell that should be passed as parameter number 10 of f
i11
index of the cell that should be passed as parameter number 11 of f
i12
index of the cell that should be passed as parameter number 12 of f
i13
index of the cell that should be passed as parameter number 13 of f
i14
index of the cell that should be passed as parameter number 14 of f
i15
index of the cell that should be passed as parameter number 15 of f
i16
index of the cell that should be passed as parameter number 16 of f
i17
index of the cell that should be passed as parameter number 17 of f
i18
index of the cell that should be passed as parameter number 18 of f

Definition Classes
GeneratedRowEncoders
def caseEncoder19[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)])(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int, i12: Int, i13: Int, i14: Int, i15: Int, i16: Int, i17: Int, i18: Int, i19: Int)(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9], arg9: CellEncoder[A10], arg10: CellEncoder[A11], arg11: CellEncoder[A12], arg12: CellEncoder[A13], arg13: CellEncoder[A14], arg14: CellEncoder[A15], arg15: CellEncoder[A16], arg16: CellEncoder[A17], arg17: CellEncoder[A18], arg18: CellEncoder[A19]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseEncoder19 to call get on the return value.
f
encoding method, intended to be a case class' unapply method.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f
i10
index of the cell that should be passed as parameter number 10 of f
i11
index of the cell that should be passed as parameter number 11 of f
i12
index of the cell that should be passed as parameter number 12 of f
i13
index of the cell that should be passed as parameter number 13 of f
i14
index of the cell that should be passed as parameter number 14 of f
i15
index of the cell that should be passed as parameter number 15 of f
i16
index of the cell that should be passed as parameter number 16 of f
i17
index of the cell that should be passed as parameter number 17 of f
i18
index of the cell that should be passed as parameter number 18 of f
i19
index of the cell that should be passed as parameter number 19 of f

Definition Classes
GeneratedRowEncoders
def caseEncoder2[C, A1, A2](f: (C) ⇒ Option[(A1, A2)])(i1: Int, i2: Int)(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseEncoder2 to call get on the return value.
f
encoding method, intended to be a case class' unapply method.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f

Definition Classes
GeneratedRowEncoders
def caseEncoder20[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)])(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int, i12: Int, i13: Int, i14: Int, i15: Int, i16: Int, i17: Int, i18: Int, i19: Int, i20: Int)(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9], arg9: CellEncoder[A10], arg10: CellEncoder[A11], arg11: CellEncoder[A12], arg12: CellEncoder[A13], arg13: CellEncoder[A14], arg14: CellEncoder[A15], arg15: CellEncoder[A16], arg16: CellEncoder[A17], arg17: CellEncoder[A18], arg18: CellEncoder[A19], arg19: CellEncoder[A20]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseEncoder20 to call get on the return value.
f
encoding method, intended to be a case class' unapply method.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f
i10
index of the cell that should be passed as parameter number 10 of f
i11
index of the cell that should be passed as parameter number 11 of f
i12
index of the cell that should be passed as parameter number 12 of f
i13
index of the cell that should be passed as parameter number 13 of f
i14
index of the cell that should be passed as parameter number 14 of f
i15
index of the cell that should be passed as parameter number 15 of f
i16
index of the cell that should be passed as parameter number 16 of f
i17
index of the cell that should be passed as parameter number 17 of f
i18
index of the cell that should be passed as parameter number 18 of f
i19
index of the cell that should be passed as parameter number 19 of f
i20
index of the cell that should be passed as parameter number 20 of f

Definition Classes
GeneratedRowEncoders
def caseEncoder21[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)])(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int, i12: Int, i13: Int, i14: Int, i15: Int, i16: Int, i17: Int, i18: Int, i19: Int, i20: Int, i21: Int)(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9], arg9: CellEncoder[A10], arg10: CellEncoder[A11], arg11: CellEncoder[A12], arg12: CellEncoder[A13], arg13: CellEncoder[A14], arg14: CellEncoder[A15], arg15: CellEncoder[A16], arg16: CellEncoder[A17], arg17: CellEncoder[A18], arg18: CellEncoder[A19], arg19: CellEncoder[A20], arg20: CellEncoder[A21]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseEncoder21 to call get on the return value.
f
encoding method, intended to be a case class' unapply method.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f
i10
index of the cell that should be passed as parameter number 10 of f
i11
index of the cell that should be passed as parameter number 11 of f
i12
index of the cell that should be passed as parameter number 12 of f
i13
index of the cell that should be passed as parameter number 13 of f
i14
index of the cell that should be passed as parameter number 14 of f
i15
index of the cell that should be passed as parameter number 15 of f
i16
index of the cell that should be passed as parameter number 16 of f
i17
index of the cell that should be passed as parameter number 17 of f
i18
index of the cell that should be passed as parameter number 18 of f
i19
index of the cell that should be passed as parameter number 19 of f
i20
index of the cell that should be passed as parameter number 20 of f
i21
index of the cell that should be passed as parameter number 21 of f

Definition Classes
GeneratedRowEncoders
def caseEncoder22[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22)])(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int, i12: Int, i13: Int, i14: Int, i15: Int, i16: Int, i17: Int, i18: Int, i19: Int, i20: Int, i21: Int, i22: Int)(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9], arg9: CellEncoder[A10], arg10: CellEncoder[A11], arg11: CellEncoder[A12], arg12: CellEncoder[A13], arg13: CellEncoder[A14], arg14: CellEncoder[A15], arg15: CellEncoder[A16], arg16: CellEncoder[A17], arg17: CellEncoder[A18], arg18: CellEncoder[A19], arg19: CellEncoder[A20], arg20: CellEncoder[A21], arg21: CellEncoder[A22]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseEncoder22 to call get on the return value.
f
encoding method, intended to be a case class' unapply method.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f
i10
index of the cell that should be passed as parameter number 10 of f
i11
index of the cell that should be passed as parameter number 11 of f
i12
index of the cell that should be passed as parameter number 12 of f
i13
index of the cell that should be passed as parameter number 13 of f
i14
index of the cell that should be passed as parameter number 14 of f
i15
index of the cell that should be passed as parameter number 15 of f
i16
index of the cell that should be passed as parameter number 16 of f
i17
index of the cell that should be passed as parameter number 17 of f
i18
index of the cell that should be passed as parameter number 18 of f
i19
index of the cell that should be passed as parameter number 19 of f
i20
index of the cell that should be passed as parameter number 20 of f
i21
index of the cell that should be passed as parameter number 21 of f
i22
index of the cell that should be passed as parameter number 22 of f

Definition Classes
GeneratedRowEncoders
def caseEncoder3[C, A1, A2, A3](f: (C) ⇒ Option[(A1, A2, A3)])(i1: Int, i2: Int, i3: Int)(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseEncoder3 to call get on the return value.
f
encoding method, intended to be a case class' unapply method.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f

Definition Classes
GeneratedRowEncoders
def caseEncoder4[C, A1, A2, A3, A4](f: (C) ⇒ Option[(A1, A2, A3, A4)])(i1: Int, i2: Int, i3: Int, i4: Int)(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseEncoder4 to call get on the return value.
f
encoding method, intended to be a case class' unapply method.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f

Definition Classes
GeneratedRowEncoders
def caseEncoder5[C, A1, A2, A3, A4, A5](f: (C) ⇒ Option[(A1, A2, A3, A4, A5)])(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int)(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseEncoder5 to call get on the return value.
f
encoding method, intended to be a case class' unapply method.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f

Definition Classes
GeneratedRowEncoders
def caseEncoder6[C, A1, A2, A3, A4, A5, A6](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6)])(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int)(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseEncoder6 to call get on the return value.
f
encoding method, intended to be a case class' unapply method.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f

Definition Classes
GeneratedRowEncoders
def caseEncoder7[C, A1, A2, A3, A4, A5, A6, A7](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7)])(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int)(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseEncoder7 to call get on the return value.
f
encoding method, intended to be a case class' unapply method.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f

Definition Classes
GeneratedRowEncoders
def caseEncoder8[C, A1, A2, A3, A4, A5, A6, A7, A8](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8)])(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int)(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseEncoder8 to call get on the return value.
f
encoding method, intended to be a case class' unapply method.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f

Definition Classes
GeneratedRowEncoders
def caseEncoder9[C, A1, A2, A3, A4, A5, A6, A7, A8, A9](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9)])(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int)(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseEncoder9 to call get on the return value.
f
encoding method, intended to be a case class' unapply method.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f

Definition Classes
GeneratedRowEncoders
def caseOrdered1[C, A1](f: (C) ⇒ Option[A1])(implicit arg0: CellEncoder[A1]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.

Definition Classes
GeneratedRowEncoders
def caseOrdered10[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9], arg9: CellEncoder[A10]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
The difference between this and caseEncoder10 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.

Definition Classes
GeneratedRowEncoders
def caseOrdered11[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9], arg9: CellEncoder[A10], arg10: CellEncoder[A11]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
The difference between this and caseEncoder11 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.

Definition Classes
GeneratedRowEncoders
def caseOrdered12[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9], arg9: CellEncoder[A10], arg10: CellEncoder[A11], arg11: CellEncoder[A12]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
The difference between this and caseEncoder12 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.

Definition Classes
GeneratedRowEncoders
def caseOrdered13[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9], arg9: CellEncoder[A10], arg10: CellEncoder[A11], arg11: CellEncoder[A12], arg12: CellEncoder[A13]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
The difference between this and caseEncoder13 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.

Definition Classes
GeneratedRowEncoders
def caseOrdered14[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9], arg9: CellEncoder[A10], arg10: CellEncoder[A11], arg11: CellEncoder[A12], arg12: CellEncoder[A13], arg13: CellEncoder[A14]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
The difference between this and caseEncoder14 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.

Definition Classes
GeneratedRowEncoders
def caseOrdered15[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9], arg9: CellEncoder[A10], arg10: CellEncoder[A11], arg11: CellEncoder[A12], arg12: CellEncoder[A13], arg13: CellEncoder[A14], arg14: CellEncoder[A15]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
The difference between this and caseEncoder15 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.

Definition Classes
GeneratedRowEncoders
def caseOrdered16[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9], arg9: CellEncoder[A10], arg10: CellEncoder[A11], arg11: CellEncoder[A12], arg12: CellEncoder[A13], arg13: CellEncoder[A14], arg14: CellEncoder[A15], arg15: CellEncoder[A16]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
The difference between this and caseEncoder16 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.

Definition Classes
GeneratedRowEncoders
def caseOrdered17[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9], arg9: CellEncoder[A10], arg10: CellEncoder[A11], arg11: CellEncoder[A12], arg12: CellEncoder[A13], arg13: CellEncoder[A14], arg14: CellEncoder[A15], arg15: CellEncoder[A16], arg16: CellEncoder[A17]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
The difference between this and caseEncoder17 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.

Definition Classes
GeneratedRowEncoders
def caseOrdered18[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9], arg9: CellEncoder[A10], arg10: CellEncoder[A11], arg11: CellEncoder[A12], arg12: CellEncoder[A13], arg13: CellEncoder[A14], arg14: CellEncoder[A15], arg15: CellEncoder[A16], arg16: CellEncoder[A17], arg17: CellEncoder[A18]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
The difference between this and caseEncoder18 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.

Definition Classes
GeneratedRowEncoders
def caseOrdered19[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9], arg9: CellEncoder[A10], arg10: CellEncoder[A11], arg11: CellEncoder[A12], arg12: CellEncoder[A13], arg13: CellEncoder[A14], arg14: CellEncoder[A15], arg15: CellEncoder[A16], arg16: CellEncoder[A17], arg17: CellEncoder[A18], arg18: CellEncoder[A19]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
The difference between this and caseEncoder19 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.

Definition Classes
GeneratedRowEncoders
def caseOrdered2[C, A1, A2](f: (C) ⇒ Option[(A1, A2)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
The difference between this and caseEncoder2 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.

Definition Classes
GeneratedRowEncoders
def caseOrdered20[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9], arg9: CellEncoder[A10], arg10: CellEncoder[A11], arg11: CellEncoder[A12], arg12: CellEncoder[A13], arg13: CellEncoder[A14], arg14: CellEncoder[A15], arg15: CellEncoder[A16], arg16: CellEncoder[A17], arg17: CellEncoder[A18], arg18: CellEncoder[A19], arg19: CellEncoder[A20]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
The difference between this and caseEncoder20 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.

Definition Classes
GeneratedRowEncoders
def caseOrdered21[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9], arg9: CellEncoder[A10], arg10: CellEncoder[A11], arg11: CellEncoder[A12], arg12: CellEncoder[A13], arg13: CellEncoder[A14], arg14: CellEncoder[A15], arg15: CellEncoder[A16], arg16: CellEncoder[A17], arg17: CellEncoder[A18], arg18: CellEncoder[A19], arg19: CellEncoder[A20], arg20: CellEncoder[A21]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
The difference between this and caseEncoder21 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.

Definition Classes
GeneratedRowEncoders
def caseOrdered22[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9], arg9: CellEncoder[A10], arg10: CellEncoder[A11], arg11: CellEncoder[A12], arg12: CellEncoder[A13], arg13: CellEncoder[A14], arg14: CellEncoder[A15], arg15: CellEncoder[A16], arg16: CellEncoder[A17], arg17: CellEncoder[A18], arg18: CellEncoder[A19], arg19: CellEncoder[A20], arg20: CellEncoder[A21], arg21: CellEncoder[A22]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
The difference between this and caseEncoder22 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.

Definition Classes
GeneratedRowEncoders
def caseOrdered3[C, A1, A2, A3](f: (C) ⇒ Option[(A1, A2, A3)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
The difference between this and caseEncoder3 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.

Definition Classes
GeneratedRowEncoders
def caseOrdered4[C, A1, A2, A3, A4](f: (C) ⇒ Option[(A1, A2, A3, A4)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
The difference between this and caseEncoder4 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.

Definition Classes
GeneratedRowEncoders
def caseOrdered5[C, A1, A2, A3, A4, A5](f: (C) ⇒ Option[(A1, A2, A3, A4, A5)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
The difference between this and caseEncoder5 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.

Definition Classes
GeneratedRowEncoders
def caseOrdered6[C, A1, A2, A3, A4, A5, A6](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
The difference between this and caseEncoder6 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.

Definition Classes
GeneratedRowEncoders
def caseOrdered7[C, A1, A2, A3, A4, A5, A6, A7](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
The difference between this and caseEncoder7 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.

Definition Classes
GeneratedRowEncoders
def caseOrdered8[C, A1, A2, A3, A4, A5, A6, A7, A8](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
The difference between this and caseEncoder8 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.

Definition Classes
GeneratedRowEncoders
def caseOrdered9[C, A1, A2, A3, A4, A5, A6, A7, A8, A9](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7], arg7: CellEncoder[A8], arg8: CellEncoder[A9]): RowEncoder[C]

Creates a new RowEncoder from the specified unapply method of a case class' companion object.
Creates a new RowEncoder from the specified unapply method of a case class' companion object.
The difference between this and caseEncoder9 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.

Definition Classes
GeneratedRowEncoders
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def encoder1[C, A1](f: (C) ⇒ A1)(implicit e1: CellEncoder[A1]): RowEncoder[C]

Creates a new RowEncoder from the specified unary function.
Creates a new RowEncoder from the specified unary function.

Definition Classes
GeneratedRowEncoders
def encoder10[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10))(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int)(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9], e10: CellEncoder[A10]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
f
encoding function.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f
i10
index of the cell that should be passed as parameter number 10 of f

Definition Classes
GeneratedRowEncoders
def encoder11[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11))(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int)(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9], e10: CellEncoder[A10], e11: CellEncoder[A11]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
f
encoding function.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f
i10
index of the cell that should be passed as parameter number 10 of f
i11
index of the cell that should be passed as parameter number 11 of f

Definition Classes
GeneratedRowEncoders
def encoder12[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12))(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int, i12: Int)(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9], e10: CellEncoder[A10], e11: CellEncoder[A11], e12: CellEncoder[A12]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
f
encoding function.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f
i10
index of the cell that should be passed as parameter number 10 of f
i11
index of the cell that should be passed as parameter number 11 of f
i12
index of the cell that should be passed as parameter number 12 of f

Definition Classes
GeneratedRowEncoders
def encoder13[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13))(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int, i12: Int, i13: Int)(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9], e10: CellEncoder[A10], e11: CellEncoder[A11], e12: CellEncoder[A12], e13: CellEncoder[A13]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
f
encoding function.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f
i10
index of the cell that should be passed as parameter number 10 of f
i11
index of the cell that should be passed as parameter number 11 of f
i12
index of the cell that should be passed as parameter number 12 of f
i13
index of the cell that should be passed as parameter number 13 of f

Definition Classes
GeneratedRowEncoders
def encoder14[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14))(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int, i12: Int, i13: Int, i14: Int)(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9], e10: CellEncoder[A10], e11: CellEncoder[A11], e12: CellEncoder[A12], e13: CellEncoder[A13], e14: CellEncoder[A14]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
f
encoding function.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f
i10
index of the cell that should be passed as parameter number 10 of f
i11
index of the cell that should be passed as parameter number 11 of f
i12
index of the cell that should be passed as parameter number 12 of f
i13
index of the cell that should be passed as parameter number 13 of f
i14
index of the cell that should be passed as parameter number 14 of f

Definition Classes
GeneratedRowEncoders
def encoder15[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15))(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int, i12: Int, i13: Int, i14: Int, i15: Int)(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9], e10: CellEncoder[A10], e11: CellEncoder[A11], e12: CellEncoder[A12], e13: CellEncoder[A13], e14: CellEncoder[A14], e15: CellEncoder[A15]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
f
encoding function.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f
i10
index of the cell that should be passed as parameter number 10 of f
i11
index of the cell that should be passed as parameter number 11 of f
i12
index of the cell that should be passed as parameter number 12 of f
i13
index of the cell that should be passed as parameter number 13 of f
i14
index of the cell that should be passed as parameter number 14 of f
i15
index of the cell that should be passed as parameter number 15 of f

Definition Classes
GeneratedRowEncoders
def encoder16[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16))(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int, i12: Int, i13: Int, i14: Int, i15: Int, i16: Int)(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9], e10: CellEncoder[A10], e11: CellEncoder[A11], e12: CellEncoder[A12], e13: CellEncoder[A13], e14: CellEncoder[A14], e15: CellEncoder[A15], e16: CellEncoder[A16]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
f
encoding function.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f
i10
index of the cell that should be passed as parameter number 10 of f
i11
index of the cell that should be passed as parameter number 11 of f
i12
index of the cell that should be passed as parameter number 12 of f
i13
index of the cell that should be passed as parameter number 13 of f
i14
index of the cell that should be passed as parameter number 14 of f
i15
index of the cell that should be passed as parameter number 15 of f
i16
index of the cell that should be passed as parameter number 16 of f

Definition Classes
GeneratedRowEncoders
def encoder17[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17))(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int, i12: Int, i13: Int, i14: Int, i15: Int, i16: Int, i17: Int)(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9], e10: CellEncoder[A10], e11: CellEncoder[A11], e12: CellEncoder[A12], e13: CellEncoder[A13], e14: CellEncoder[A14], e15: CellEncoder[A15], e16: CellEncoder[A16], e17: CellEncoder[A17]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
f
encoding function.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f
i10
index of the cell that should be passed as parameter number 10 of f
i11
index of the cell that should be passed as parameter number 11 of f
i12
index of the cell that should be passed as parameter number 12 of f
i13
index of the cell that should be passed as parameter number 13 of f
i14
index of the cell that should be passed as parameter number 14 of f
i15
index of the cell that should be passed as parameter number 15 of f
i16
index of the cell that should be passed as parameter number 16 of f
i17
index of the cell that should be passed as parameter number 17 of f

Definition Classes
GeneratedRowEncoders
def encoder18[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18))(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int, i12: Int, i13: Int, i14: Int, i15: Int, i16: Int, i17: Int, i18: Int)(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9], e10: CellEncoder[A10], e11: CellEncoder[A11], e12: CellEncoder[A12], e13: CellEncoder[A13], e14: CellEncoder[A14], e15: CellEncoder[A15], e16: CellEncoder[A16], e17: CellEncoder[A17], e18: CellEncoder[A18]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
f
encoding function.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f
i10
index of the cell that should be passed as parameter number 10 of f
i11
index of the cell that should be passed as parameter number 11 of f
i12
index of the cell that should be passed as parameter number 12 of f
i13
index of the cell that should be passed as parameter number 13 of f
i14
index of the cell that should be passed as parameter number 14 of f
i15
index of the cell that should be passed as parameter number 15 of f
i16
index of the cell that should be passed as parameter number 16 of f
i17
index of the cell that should be passed as parameter number 17 of f
i18
index of the cell that should be passed as parameter number 18 of f

Definition Classes
GeneratedRowEncoders
def encoder19[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19))(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int, i12: Int, i13: Int, i14: Int, i15: Int, i16: Int, i17: Int, i18: Int, i19: Int)(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9], e10: CellEncoder[A10], e11: CellEncoder[A11], e12: CellEncoder[A12], e13: CellEncoder[A13], e14: CellEncoder[A14], e15: CellEncoder[A15], e16: CellEncoder[A16], e17: CellEncoder[A17], e18: CellEncoder[A18], e19: CellEncoder[A19]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
f
encoding function.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f
i10
index of the cell that should be passed as parameter number 10 of f
i11
index of the cell that should be passed as parameter number 11 of f
i12
index of the cell that should be passed as parameter number 12 of f
i13
index of the cell that should be passed as parameter number 13 of f
i14
index of the cell that should be passed as parameter number 14 of f
i15
index of the cell that should be passed as parameter number 15 of f
i16
index of the cell that should be passed as parameter number 16 of f
i17
index of the cell that should be passed as parameter number 17 of f
i18
index of the cell that should be passed as parameter number 18 of f
i19
index of the cell that should be passed as parameter number 19 of f

Definition Classes
GeneratedRowEncoders
def encoder2[C, A1, A2](f: (C) ⇒ (A1, A2))(i1: Int, i2: Int)(implicit e1: CellEncoder[A1], e2: CellEncoder[A2]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
f
encoding function.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f

Definition Classes
GeneratedRowEncoders
def encoder20[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20))(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int, i12: Int, i13: Int, i14: Int, i15: Int, i16: Int, i17: Int, i18: Int, i19: Int, i20: Int)(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9], e10: CellEncoder[A10], e11: CellEncoder[A11], e12: CellEncoder[A12], e13: CellEncoder[A13], e14: CellEncoder[A14], e15: CellEncoder[A15], e16: CellEncoder[A16], e17: CellEncoder[A17], e18: CellEncoder[A18], e19: CellEncoder[A19], e20: CellEncoder[A20]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
f
encoding function.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f
i10
index of the cell that should be passed as parameter number 10 of f
i11
index of the cell that should be passed as parameter number 11 of f
i12
index of the cell that should be passed as parameter number 12 of f
i13
index of the cell that should be passed as parameter number 13 of f
i14
index of the cell that should be passed as parameter number 14 of f
i15
index of the cell that should be passed as parameter number 15 of f
i16
index of the cell that should be passed as parameter number 16 of f
i17
index of the cell that should be passed as parameter number 17 of f
i18
index of the cell that should be passed as parameter number 18 of f
i19
index of the cell that should be passed as parameter number 19 of f
i20
index of the cell that should be passed as parameter number 20 of f

Definition Classes
GeneratedRowEncoders
def encoder21[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21))(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int, i12: Int, i13: Int, i14: Int, i15: Int, i16: Int, i17: Int, i18: Int, i19: Int, i20: Int, i21: Int)(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9], e10: CellEncoder[A10], e11: CellEncoder[A11], e12: CellEncoder[A12], e13: CellEncoder[A13], e14: CellEncoder[A14], e15: CellEncoder[A15], e16: CellEncoder[A16], e17: CellEncoder[A17], e18: CellEncoder[A18], e19: CellEncoder[A19], e20: CellEncoder[A20], e21: CellEncoder[A21]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
f
encoding function.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f
i10
index of the cell that should be passed as parameter number 10 of f
i11
index of the cell that should be passed as parameter number 11 of f
i12
index of the cell that should be passed as parameter number 12 of f
i13
index of the cell that should be passed as parameter number 13 of f
i14
index of the cell that should be passed as parameter number 14 of f
i15
index of the cell that should be passed as parameter number 15 of f
i16
index of the cell that should be passed as parameter number 16 of f
i17
index of the cell that should be passed as parameter number 17 of f
i18
index of the cell that should be passed as parameter number 18 of f
i19
index of the cell that should be passed as parameter number 19 of f
i20
index of the cell that should be passed as parameter number 20 of f
i21
index of the cell that should be passed as parameter number 21 of f

Definition Classes
GeneratedRowEncoders
def encoder22[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22))(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int, i12: Int, i13: Int, i14: Int, i15: Int, i16: Int, i17: Int, i18: Int, i19: Int, i20: Int, i21: Int, i22: Int)(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9], e10: CellEncoder[A10], e11: CellEncoder[A11], e12: CellEncoder[A12], e13: CellEncoder[A13], e14: CellEncoder[A14], e15: CellEncoder[A15], e16: CellEncoder[A16], e17: CellEncoder[A17], e18: CellEncoder[A18], e19: CellEncoder[A19], e20: CellEncoder[A20], e21: CellEncoder[A21], e22: CellEncoder[A22]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
f
encoding function.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f
i10
index of the cell that should be passed as parameter number 10 of f
i11
index of the cell that should be passed as parameter number 11 of f
i12
index of the cell that should be passed as parameter number 12 of f
i13
index of the cell that should be passed as parameter number 13 of f
i14
index of the cell that should be passed as parameter number 14 of f
i15
index of the cell that should be passed as parameter number 15 of f
i16
index of the cell that should be passed as parameter number 16 of f
i17
index of the cell that should be passed as parameter number 17 of f
i18
index of the cell that should be passed as parameter number 18 of f
i19
index of the cell that should be passed as parameter number 19 of f
i20
index of the cell that should be passed as parameter number 20 of f
i21
index of the cell that should be passed as parameter number 21 of f
i22
index of the cell that should be passed as parameter number 22 of f

Definition Classes
GeneratedRowEncoders
def encoder3[C, A1, A2, A3](f: (C) ⇒ (A1, A2, A3))(i1: Int, i2: Int, i3: Int)(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
f
encoding function.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f

Definition Classes
GeneratedRowEncoders
def encoder4[C, A1, A2, A3, A4](f: (C) ⇒ (A1, A2, A3, A4))(i1: Int, i2: Int, i3: Int, i4: Int)(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
f
encoding function.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f

Definition Classes
GeneratedRowEncoders
def encoder5[C, A1, A2, A3, A4, A5](f: (C) ⇒ (A1, A2, A3, A4, A5))(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int)(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
f
encoding function.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f

Definition Classes
GeneratedRowEncoders
def encoder6[C, A1, A2, A3, A4, A5, A6](f: (C) ⇒ (A1, A2, A3, A4, A5, A6))(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int)(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
f
encoding function.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f

Definition Classes
GeneratedRowEncoders
def encoder7[C, A1, A2, A3, A4, A5, A6, A7](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7))(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int)(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
f
encoding function.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f

Definition Classes
GeneratedRowEncoders
def encoder8[C, A1, A2, A3, A4, A5, A6, A7, A8](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8))(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int)(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
f
encoding function.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f

Definition Classes
GeneratedRowEncoders
def encoder9[C, A1, A2, A3, A4, A5, A6, A7, A8, A9](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9))(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int)(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
f
encoding function.
i1
index of the cell that should be passed as parameter number 1 of f
i2
index of the cell that should be passed as parameter number 2 of f
i3
index of the cell that should be passed as parameter number 3 of f
i4
index of the cell that should be passed as parameter number 4 of f
i5
index of the cell that should be passed as parameter number 5 of f
i6
index of the cell that should be passed as parameter number 6 of f
i7
index of the cell that should be passed as parameter number 7 of f
i8
index of the cell that should be passed as parameter number 8 of f
i9
index of the cell that should be passed as parameter number 9 of f

Definition Classes
GeneratedRowEncoders
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def ordered1[C, A1](f: (C) ⇒ A1)(implicit arg0: CellEncoder[A1]): RowEncoder[C]

Creates a new RowEncoder from the specified unary function.
Creates a new RowEncoder from the specified unary function.

Definition Classes
GeneratedRowEncoders
def ordered10[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9], e10: CellEncoder[A10]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
The difference between this and encoder10 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.

Definition Classes
GeneratedRowEncoders
def ordered11[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9], e10: CellEncoder[A10], e11: CellEncoder[A11]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
The difference between this and encoder11 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.

Definition Classes
GeneratedRowEncoders
def ordered12[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9], e10: CellEncoder[A10], e11: CellEncoder[A11], e12: CellEncoder[A12]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
The difference between this and encoder12 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.

Definition Classes
GeneratedRowEncoders
def ordered13[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9], e10: CellEncoder[A10], e11: CellEncoder[A11], e12: CellEncoder[A12], e13: CellEncoder[A13]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
The difference between this and encoder13 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.

Definition Classes
GeneratedRowEncoders
def ordered14[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9], e10: CellEncoder[A10], e11: CellEncoder[A11], e12: CellEncoder[A12], e13: CellEncoder[A13], e14: CellEncoder[A14]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
The difference between this and encoder14 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.

Definition Classes
GeneratedRowEncoders
def ordered15[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9], e10: CellEncoder[A10], e11: CellEncoder[A11], e12: CellEncoder[A12], e13: CellEncoder[A13], e14: CellEncoder[A14], e15: CellEncoder[A15]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
The difference between this and encoder15 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.

Definition Classes
GeneratedRowEncoders
def ordered16[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9], e10: CellEncoder[A10], e11: CellEncoder[A11], e12: CellEncoder[A12], e13: CellEncoder[A13], e14: CellEncoder[A14], e15: CellEncoder[A15], e16: CellEncoder[A16]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
The difference between this and encoder16 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.

Definition Classes
GeneratedRowEncoders
def ordered17[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9], e10: CellEncoder[A10], e11: CellEncoder[A11], e12: CellEncoder[A12], e13: CellEncoder[A13], e14: CellEncoder[A14], e15: CellEncoder[A15], e16: CellEncoder[A16], e17: CellEncoder[A17]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
The difference between this and encoder17 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.

Definition Classes
GeneratedRowEncoders
def ordered18[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9], e10: CellEncoder[A10], e11: CellEncoder[A11], e12: CellEncoder[A12], e13: CellEncoder[A13], e14: CellEncoder[A14], e15: CellEncoder[A15], e16: CellEncoder[A16], e17: CellEncoder[A17], e18: CellEncoder[A18]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
The difference between this and encoder18 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.

Definition Classes
GeneratedRowEncoders
def ordered19[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9], e10: CellEncoder[A10], e11: CellEncoder[A11], e12: CellEncoder[A12], e13: CellEncoder[A13], e14: CellEncoder[A14], e15: CellEncoder[A15], e16: CellEncoder[A16], e17: CellEncoder[A17], e18: CellEncoder[A18], e19: CellEncoder[A19]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
The difference between this and encoder19 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.

Definition Classes
GeneratedRowEncoders
def ordered2[C, A1, A2](f: (C) ⇒ (A1, A2))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
The difference between this and encoder2 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.

Definition Classes
GeneratedRowEncoders
def ordered20[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9], e10: CellEncoder[A10], e11: CellEncoder[A11], e12: CellEncoder[A12], e13: CellEncoder[A13], e14: CellEncoder[A14], e15: CellEncoder[A15], e16: CellEncoder[A16], e17: CellEncoder[A17], e18: CellEncoder[A18], e19: CellEncoder[A19], e20: CellEncoder[A20]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
The difference between this and encoder20 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.

Definition Classes
GeneratedRowEncoders
def ordered21[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9], e10: CellEncoder[A10], e11: CellEncoder[A11], e12: CellEncoder[A12], e13: CellEncoder[A13], e14: CellEncoder[A14], e15: CellEncoder[A15], e16: CellEncoder[A16], e17: CellEncoder[A17], e18: CellEncoder[A18], e19: CellEncoder[A19], e20: CellEncoder[A20], e21: CellEncoder[A21]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
The difference between this and encoder21 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.

Definition Classes
GeneratedRowEncoders
def ordered22[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9], e10: CellEncoder[A10], e11: CellEncoder[A11], e12: CellEncoder[A12], e13: CellEncoder[A13], e14: CellEncoder[A14], e15: CellEncoder[A15], e16: CellEncoder[A16], e17: CellEncoder[A17], e18: CellEncoder[A18], e19: CellEncoder[A19], e20: CellEncoder[A20], e21: CellEncoder[A21], e22: CellEncoder[A22]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
The difference between this and encoder22 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.

Definition Classes
GeneratedRowEncoders
def ordered3[C, A1, A2, A3](f: (C) ⇒ (A1, A2, A3))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
The difference between this and encoder3 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.

Definition Classes
GeneratedRowEncoders
def ordered4[C, A1, A2, A3, A4](f: (C) ⇒ (A1, A2, A3, A4))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
The difference between this and encoder4 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.

Definition Classes
GeneratedRowEncoders
def ordered5[C, A1, A2, A3, A4, A5](f: (C) ⇒ (A1, A2, A3, A4, A5))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
The difference between this and encoder5 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.

Definition Classes
GeneratedRowEncoders
def ordered6[C, A1, A2, A3, A4, A5, A6](f: (C) ⇒ (A1, A2, A3, A4, A5, A6))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
The difference between this and encoder6 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.

Definition Classes
GeneratedRowEncoders
def ordered7[C, A1, A2, A3, A4, A5, A6, A7](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
The difference between this and encoder7 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.

Definition Classes
GeneratedRowEncoders
def ordered8[C, A1, A2, A3, A4, A5, A6, A7, A8](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
The difference between this and encoder8 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.

Definition Classes
GeneratedRowEncoders
def ordered9[C, A1, A2, A3, A4, A5, A6, A7, A8, A9](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8], e9: CellEncoder[A9]): RowEncoder[C]

Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
The difference between this and encoder9 is that the former expects CSV cells to be ordered in the exact same sequence as the parameters expected by the specified function, while the later lets you customise these indexes.

Definition Classes
GeneratedRowEncoders
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
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( ... )

Related Doc: package csv

object RowEncoder extends GeneratedRowEncoders

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def apply[A](f: (A) ⇒ Seq[String]): RowEncoder[A]

def apply[A](implicit ea: RowEncoder[A]): RowEncoder[A]

final def asInstanceOf[T0]: T0

def caseEncoder1[C, A1](f: (C) ⇒ Option[A1])(implicit arg0: CellEncoder[A1]): RowEncoder[C]

def caseEncoder2[C, A1, A2](f: (C) ⇒ Option[(A1, A2)])(i1: Int, i2: Int)(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2]): RowEncoder[C]

def caseEncoder3[C, A1, A2, A3](f: (C) ⇒ Option[(A1, A2, A3)])(i1: Int, i2: Int, i3: Int)(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3]): RowEncoder[C]

def caseEncoder4[C, A1, A2, A3, A4](f: (C) ⇒ Option[(A1, A2, A3, A4)])(i1: Int, i2: Int, i3: Int, i4: Int)(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4]): RowEncoder[C]

def caseEncoder5[C, A1, A2, A3, A4, A5](f: (C) ⇒ Option[(A1, A2, A3, A4, A5)])(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int)(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5]): RowEncoder[C]

def caseOrdered1[C, A1](f: (C) ⇒ Option[A1])(implicit arg0: CellEncoder[A1]): RowEncoder[C]

def caseOrdered2[C, A1, A2](f: (C) ⇒ Option[(A1, A2)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2]): RowEncoder[C]

def caseOrdered3[C, A1, A2, A3](f: (C) ⇒ Option[(A1, A2, A3)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3]): RowEncoder[C]

def caseOrdered4[C, A1, A2, A3, A4](f: (C) ⇒ Option[(A1, A2, A3, A4)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4]): RowEncoder[C]

def caseOrdered5[C, A1, A2, A3, A4, A5](f: (C) ⇒ Option[(A1, A2, A3, A4, A5)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5]): RowEncoder[C]

def caseOrdered6[C, A1, A2, A3, A4, A5, A6](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6]): RowEncoder[C]

def caseOrdered7[C, A1, A2, A3, A4, A5, A6, A7](f: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7)])(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3], arg3: CellEncoder[A4], arg4: CellEncoder[A5], arg5: CellEncoder[A6], arg6: CellEncoder[A7]): RowEncoder[C]

def clone(): AnyRef

def encoder1[C, A1](f: (C) ⇒ A1)(implicit e1: CellEncoder[A1]): RowEncoder[C]

def encoder2[C, A1, A2](f: (C) ⇒ (A1, A2))(i1: Int, i2: Int)(implicit e1: CellEncoder[A1], e2: CellEncoder[A2]): RowEncoder[C]

def encoder3[C, A1, A2, A3](f: (C) ⇒ (A1, A2, A3))(i1: Int, i2: Int, i3: Int)(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3]): RowEncoder[C]

def encoder4[C, A1, A2, A3, A4](f: (C) ⇒ (A1, A2, A3, A4))(i1: Int, i2: Int, i3: Int, i4: Int)(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4]): RowEncoder[C]

def encoder5[C, A1, A2, A3, A4, A5](f: (C) ⇒ (A1, A2, A3, A4, A5))(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int)(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5]): RowEncoder[C]

def encoder6[C, A1, A2, A3, A4, A5, A6](f: (C) ⇒ (A1, A2, A3, A4, A5, A6))(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int)(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6]): RowEncoder[C]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def ordered1[C, A1](f: (C) ⇒ A1)(implicit arg0: CellEncoder[A1]): RowEncoder[C]

def ordered2[C, A1, A2](f: (C) ⇒ (A1, A2))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2]): RowEncoder[C]

def ordered3[C, A1, A2, A3](f: (C) ⇒ (A1, A2, A3))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3]): RowEncoder[C]

def ordered4[C, A1, A2, A3, A4](f: (C) ⇒ (A1, A2, A3, A4))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4]): RowEncoder[C]

def ordered5[C, A1, A2, A3, A4, A5](f: (C) ⇒ (A1, A2, A3, A4, A5))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5]): RowEncoder[C]

def ordered6[C, A1, A2, A3, A4, A5, A6](f: (C) ⇒ (A1, A2, A3, A4, A5, A6))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6]): RowEncoder[C]

def ordered7[C, A1, A2, A3, A4, A5, A6, A7](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7]): RowEncoder[C]

def ordered8[C, A1, A2, A3, A4, A5, A6, A7, A8](f: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8))(implicit e1: CellEncoder[A1], e2: CellEncoder[A2], e3: CellEncoder[A3], e4: CellEncoder[A4], e5: CellEncoder[A5], e6: CellEncoder[A6], e7: CellEncoder[A7], e8: CellEncoder[A8]): RowEncoder[C]

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from GeneratedRowEncoders

Inherited from AnyRef

Inherited from Any

Ungrouped