RowEncoder

object RowEncoder extends GeneratedRowEncoders with EncoderCompanion[Seq[String], codecs.type]

Provides various instance creation and summoning methods.

The instance creation functions are important to know about, as they make the task of creating new encoders easier and more correct. There are four main families, depending on the type to encode:

encoder: creates encoders from a function for which you need to specify a mapping row index to parameter (such as if you need to skip some CSV cells, for instance).
ordered: create encoders from a function such that its parameters are organised in exactly the same way as CSV rows.
caseEncoder: specialisation of encoder for case classes.
caseOrdered: specialisation of ordered for case classes.

Note that a lot of types already have implicit instances: tuples, collections... moreover, the generics module can automatically derive valid instances for a lot of common scenarios.

Source: RowEncoder.scala

Linear Supertypes

EncoderCompanion[Seq[String], codecs.type], GeneratedRowEncoders, AnyRef, Any

Ordering

Alphabetic
By Inheritance

Inherited

RowEncoder
EncoderCompanion
GeneratedRowEncoders
AnyRef
Any

Hide All
Show All

Visibility

Public
Protected

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
macro def apply[D](implicit ev: Encoder[Seq[String], D, codecs.type]): Encoder[Seq[String], D, codecs.type]
Definition Classes
EncoderCompanion
final def asInstanceOf[T0]: T0
Definition Classes
Any
def caseEncoder[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)(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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseEncoder22 to call get on the return value.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.caseEncoder(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21)(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22))
res21: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22)
```
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
f
encoding method, intended to be a case class' unapply method.
Definition Classes
GeneratedRowEncoders
def caseEncoder[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)(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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseEncoder21 to call get on the return value.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.caseEncoder(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21))
res20: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21)
```
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
f
encoding method, intended to be a case class' unapply method.
Definition Classes
GeneratedRowEncoders
def caseEncoder[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)(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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseEncoder20 to call get on the return value.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.caseEncoder(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19)(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20))
res19: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)
```
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
f
encoding method, intended to be a case class' unapply method.
Definition Classes
GeneratedRowEncoders
def caseEncoder[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)(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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseEncoder19 to call get on the return value.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.caseEncoder(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18)(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19))
res18: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19)
```
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
f
encoding method, intended to be a case class' unapply method.
Definition Classes
GeneratedRowEncoders
def caseEncoder[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)(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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseEncoder18 to call get on the return value.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.caseEncoder(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17)(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18))
res17: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18)
```
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
f
encoding method, intended to be a case class' unapply method.
Definition Classes
GeneratedRowEncoders
def caseEncoder[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)(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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseEncoder17 to call get on the return value.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.caseEncoder(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17))
res16: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17)
```
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
f
encoding method, intended to be a case class' unapply method.
Definition Classes
GeneratedRowEncoders
def caseEncoder[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)(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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseEncoder16 to call get on the return value.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.caseEncoder(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16))
res15: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)
```
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
f
encoding method, intended to be a case class' unapply method.
Definition Classes
GeneratedRowEncoders
def caseEncoder[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)(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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseEncoder15 to call get on the return value.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.caseEncoder(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15))
res14: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
```
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
f
encoding method, intended to be a case class' unapply method.
Definition Classes
GeneratedRowEncoders
def caseEncoder[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)(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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseEncoder14 to call get on the return value.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.caseEncoder(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14))
res13: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)
```
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
f
encoding method, intended to be a case class' unapply method.
Definition Classes
GeneratedRowEncoders
def caseEncoder[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)(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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseEncoder13 to call get on the return value.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.caseEncoder(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13))
res12: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)
```
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
f
encoding method, intended to be a case class' unapply method.
Definition Classes
GeneratedRowEncoders
def caseEncoder[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)(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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseEncoder12 to call get on the return value.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int, i12: Int)

scala> RowEncoder.caseEncoder(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12))
res11: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
```
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
f
encoding method, intended to be a case class' unapply method.
Definition Classes
GeneratedRowEncoders
def caseEncoder[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)(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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseEncoder11 to call get on the return value.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int)

scala> RowEncoder.caseEncoder(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11))
res10: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
```
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
f
encoding method, intended to be a case class' unapply method.
Definition Classes
GeneratedRowEncoders
def caseEncoder[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)(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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseEncoder10 to call get on the return value.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int)

scala> RowEncoder.caseEncoder(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
res9: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
```
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
f
encoding method, intended to be a case class' unapply method.
Definition Classes
GeneratedRowEncoders
def caseEncoder[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)(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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseEncoder9 to call get on the return value.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int)

scala> RowEncoder.caseEncoder(0, 1, 2, 3, 4, 5, 6, 7, 8)(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9))
res8: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9)
```
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
f
encoding method, intended to be a case class' unapply method.
Definition Classes
GeneratedRowEncoders
def caseEncoder[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)(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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseEncoder8 to call get on the return value.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int)

scala> RowEncoder.caseEncoder(0, 1, 2, 3, 4, 5, 6, 7)(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8))
res7: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8)
```
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
f
encoding method, intended to be a case class' unapply method.
Definition Classes
GeneratedRowEncoders
def caseEncoder[C, A1, A2, A3, A4, A5, A6, A7](i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int)(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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseEncoder7 to call get on the return value.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int)

scala> RowEncoder.caseEncoder(0, 1, 2, 3, 4, 5, 6)(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7))
res6: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7)
```
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
f
encoding method, intended to be a case class' unapply method.
Definition Classes
GeneratedRowEncoders
def caseEncoder[C, A1, A2, A3, A4, A5, A6](i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int)(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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseEncoder6 to call get on the return value.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int)

scala> RowEncoder.caseEncoder(0, 1, 2, 3, 4, 5)(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6))
res5: Seq[String] = Vector(1, 2, 3, 4, 5, 6)
```
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
f
encoding method, intended to be a case class' unapply method.
Definition Classes
GeneratedRowEncoders
def caseEncoder[C, A1, A2, A3, A4, A5](i1: Int, i2: Int, i3: Int, i4: Int, i5: Int)(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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseEncoder5 to call get on the return value.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int)

scala> RowEncoder.caseEncoder(0, 1, 2, 3, 4)(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5))
res4: Seq[String] = Vector(1, 2, 3, 4, 5)
```
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
f
encoding method, intended to be a case class' unapply method.
Definition Classes
GeneratedRowEncoders
def caseEncoder[C, A1, A2, A3, A4](i1: Int, i2: Int, i3: Int, i4: Int)(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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseEncoder4 to call get on the return value.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int)

scala> RowEncoder.caseEncoder(0, 1, 2, 3)(Ints.unapply _).encode(Ints(1, 2, 3, 4))
res3: Seq[String] = Vector(1, 2, 3, 4)
```
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
f
encoding method, intended to be a case class' unapply method.
Definition Classes
GeneratedRowEncoders
def caseEncoder[C, A1, A2, A3](i1: Int, i2: Int, i3: Int)(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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseEncoder3 to call get on the return value.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int)

scala> RowEncoder.caseEncoder(0, 1, 2)(Ints.unapply _).encode(Ints(1, 2, 3))
res2: Seq[String] = Vector(1, 2, 3)
```
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
f
encoding method, intended to be a case class' unapply method.
Definition Classes
GeneratedRowEncoders
def caseEncoder[C, A1, A2](i1: Int, i2: Int)(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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseEncoder2 to call get on the return value.
For example:
```
scala> case class Ints(i1: Int, i2: Int)

scala> RowEncoder.caseEncoder(0, 1)(Ints.unapply _).encode(Ints(1, 2))
res1: Seq[String] = Vector(1, 2)
```
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
f
encoding method, intended to be a case class' unapply method.
Definition Classes
GeneratedRowEncoders
def caseEncoder[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 None, which allows caseEncoder1 to call get on the return value.
For example:
```
scala> case class Ints(i1: Int)

scala> RowEncoder.caseEncoder(Ints.unapply _).encode(Ints(1))
res0: Seq[String] = List(1)
```
f
encoding method, intended to be a case class' unapply method.
Definition Classes
GeneratedRowEncoders
def caseOrdered[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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseOrdered to call get on the return value.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.caseOrdered(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22))
res21: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22)
```
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.
Definition Classes
GeneratedRowEncoders
def caseOrdered[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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseOrdered to call get on the return value.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.caseOrdered(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21))
res20: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21)
```
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.
Definition Classes
GeneratedRowEncoders
def caseOrdered[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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseOrdered to call get on the return value.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.caseOrdered(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20))
res19: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)
```
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.
Definition Classes
GeneratedRowEncoders
def caseOrdered[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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseOrdered to call get on the return value.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.caseOrdered(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19))
res18: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19)
```
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.
Definition Classes
GeneratedRowEncoders
def caseOrdered[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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseOrdered to call get on the return value.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.caseOrdered(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18))
res17: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18)
```
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.
Definition Classes
GeneratedRowEncoders
def caseOrdered[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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseOrdered to call get on the return value.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.caseOrdered(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17))
res16: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17)
```
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.
Definition Classes
GeneratedRowEncoders
def caseOrdered[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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseOrdered to call get on the return value.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.caseOrdered(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16))
res15: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)
```
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.
Definition Classes
GeneratedRowEncoders
def caseOrdered[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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseOrdered to call get on the return value.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.caseOrdered(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15))
res14: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
```
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.
Definition Classes
GeneratedRowEncoders
def caseOrdered[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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseOrdered to call get on the return value.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.caseOrdered(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14))
res13: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)
```
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.
Definition Classes
GeneratedRowEncoders
def caseOrdered[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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseOrdered to call get on the return value.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.caseOrdered(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13))
res12: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)
```
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.
Definition Classes
GeneratedRowEncoders
def caseOrdered[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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseOrdered to call get on the return value.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int, i12: Int)

scala> RowEncoder.caseOrdered(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12))
res11: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
```
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.
Definition Classes
GeneratedRowEncoders
def caseOrdered[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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseOrdered to call get on the return value.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int)

scala> RowEncoder.caseOrdered(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11))
res10: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
```
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.
Definition Classes
GeneratedRowEncoders
def caseOrdered[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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseOrdered to call get on the return value.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int)

scala> RowEncoder.caseOrdered(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
res9: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
```
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.
Definition Classes
GeneratedRowEncoders
def caseOrdered[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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseOrdered to call get on the return value.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int)

scala> RowEncoder.caseOrdered(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9))
res8: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9)
```
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.
Definition Classes
GeneratedRowEncoders
def caseOrdered[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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseOrdered to call get on the return value.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int)

scala> RowEncoder.caseOrdered(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8))
res7: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8)
```
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.
Definition Classes
GeneratedRowEncoders
def caseOrdered[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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseOrdered to call get on the return value.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int)

scala> RowEncoder.caseOrdered(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6, 7))
res6: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7)
```
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.
Definition Classes
GeneratedRowEncoders
def caseOrdered[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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseOrdered to call get on the return value.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int)

scala> RowEncoder.caseOrdered(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5, 6))
res5: Seq[String] = Vector(1, 2, 3, 4, 5, 6)
```
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.
Definition Classes
GeneratedRowEncoders
def caseOrdered[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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseOrdered to call get on the return value.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int)

scala> RowEncoder.caseOrdered(Ints.unapply _).encode(Ints(1, 2, 3, 4, 5))
res4: Seq[String] = Vector(1, 2, 3, 4, 5)
```
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.
Definition Classes
GeneratedRowEncoders
def caseOrdered[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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseOrdered to call get on the return value.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int)

scala> RowEncoder.caseOrdered(Ints.unapply _).encode(Ints(1, 2, 3, 4))
res3: Seq[String] = Vector(1, 2, 3, 4)
```
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.
Definition Classes
GeneratedRowEncoders
def caseOrdered[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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseOrdered to call get on the return value.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int)

scala> RowEncoder.caseOrdered(Ints.unapply _).encode(Ints(1, 2, 3))
res2: Seq[String] = Vector(1, 2, 3)
```
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.
Definition Classes
GeneratedRowEncoders
def caseOrdered[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.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns None, which allows caseOrdered to call get on the return value.
For example:
```
scala> case class Ints(i1: Int, i2: Int)

scala> RowEncoder.caseOrdered(Ints.unapply _).encode(Ints(1, 2))
res1: Seq[String] = Vector(1, 2)
```
Consider using the generics kantan.csv module instead: it can automatically derive instances for this use case.
Definition Classes
GeneratedRowEncoders
def caseOrdered[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 None, which allows caseOrdered to call get on the return value.
For example:
```
scala> case class Ints(i1: Int)

scala> RowEncoder.caseOrdered(Ints.unapply _).encode(Ints(1))
res0: Seq[String] = List(1)
```
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[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.CloneNotSupportedException]) @native()
def encoder[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)(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 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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.encoder(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21)((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10, is.i11, is.i12, is.i13, is.i14, is.i15, is.i16, is.i17, is.i18, is.i19, is.i20, is.i21, is.i22)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22))
res21: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22)
```
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
f
encoding function.
Definition Classes
GeneratedRowEncoders
def encoder[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)(f: (C) => (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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.encoder(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10, is.i11, is.i12, is.i13, is.i14, is.i15, is.i16, is.i17, is.i18, is.i19, is.i20, is.i21)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21))
res20: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21)
```
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
f
encoding function.
Definition Classes
GeneratedRowEncoders
def encoder[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)(f: (C) => (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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.encoder(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19)((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10, is.i11, is.i12, is.i13, is.i14, is.i15, is.i16, is.i17, is.i18, is.i19, is.i20)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20))
res19: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)
```
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
f
encoding function.
Definition Classes
GeneratedRowEncoders
def encoder[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)(f: (C) => (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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.encoder(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18)((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10, is.i11, is.i12, is.i13, is.i14, is.i15, is.i16, is.i17, is.i18, is.i19)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19))
res18: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19)
```
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
f
encoding function.
Definition Classes
GeneratedRowEncoders
def encoder[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)(f: (C) => (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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.encoder(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17)((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10, is.i11, is.i12, is.i13, is.i14, is.i15, is.i16, is.i17, is.i18)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18))
res17: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18)
```
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
f
encoding function.
Definition Classes
GeneratedRowEncoders
def encoder[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)(f: (C) => (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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.encoder(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10, is.i11, is.i12, is.i13, is.i14, is.i15, is.i16, is.i17)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17))
res16: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17)
```
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
f
encoding function.
Definition Classes
GeneratedRowEncoders
def encoder[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)(f: (C) => (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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.encoder(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10, is.i11, is.i12, is.i13, is.i14, is.i15, is.i16)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16))
res15: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)
```
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
f
encoding function.
Definition Classes
GeneratedRowEncoders
def encoder[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)(f: (C) => (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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.encoder(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10, is.i11, is.i12, is.i13, is.i14, is.i15)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15))
res14: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
```
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
f
encoding function.
Definition Classes
GeneratedRowEncoders
def encoder[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)(f: (C) => (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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.encoder(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10, is.i11, is.i12, is.i13, is.i14)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14))
res13: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)
```
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
f
encoding function.
Definition Classes
GeneratedRowEncoders
def encoder[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)(f: (C) => (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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.encoder(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10, is.i11, is.i12, is.i13)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13))
res12: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)
```
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
f
encoding function.
Definition Classes
GeneratedRowEncoders
def encoder[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)(f: (C) => (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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int, i12: Int)

scala> RowEncoder.encoder(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10, is.i11, is.i12)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12))
res11: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
```
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
f
encoding function.
Definition Classes
GeneratedRowEncoders
def encoder[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)(f: (C) => (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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int)

scala> RowEncoder.encoder(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10, is.i11)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11))
res10: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
```
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
f
encoding function.
Definition Classes
GeneratedRowEncoders
def encoder[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)(f: (C) => (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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int)

scala> RowEncoder.encoder(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
res9: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
```
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
f
encoding function.
Definition Classes
GeneratedRowEncoders
def encoder[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)(f: (C) => (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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int)

scala> RowEncoder.encoder(0, 1, 2, 3, 4, 5, 6, 7, 8)((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9))
res8: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9)
```
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
f
encoding function.
Definition Classes
GeneratedRowEncoders
def encoder[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)(f: (C) => (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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int)

scala> RowEncoder.encoder(0, 1, 2, 3, 4, 5, 6, 7)((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8))
res7: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8)
```
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
f
encoding function.
Definition Classes
GeneratedRowEncoders
def encoder[C, A1, A2, A3, A4, A5, A6, A7](i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int)(f: (C) => (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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int)

scala> RowEncoder.encoder(0, 1, 2, 3, 4, 5, 6)((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7)).encode(Ints(1, 2, 3, 4, 5, 6, 7))
res6: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7)
```
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
f
encoding function.
Definition Classes
GeneratedRowEncoders
def encoder[C, A1, A2, A3, A4, A5, A6](i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int)(f: (C) => (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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int)

scala> RowEncoder.encoder(0, 1, 2, 3, 4, 5)((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6)).encode(Ints(1, 2, 3, 4, 5, 6))
res5: Seq[String] = Vector(1, 2, 3, 4, 5, 6)
```
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
f
encoding function.
Definition Classes
GeneratedRowEncoders
def encoder[C, A1, A2, A3, A4, A5](i1: Int, i2: Int, i3: Int, i4: Int, i5: Int)(f: (C) => (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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int)

scala> RowEncoder.encoder(0, 1, 2, 3, 4)((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5)).encode(Ints(1, 2, 3, 4, 5))
res4: Seq[String] = Vector(1, 2, 3, 4, 5)
```
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
f
encoding function.
Definition Classes
GeneratedRowEncoders
def encoder[C, A1, A2, A3, A4](i1: Int, i2: Int, i3: Int, i4: Int)(f: (C) => (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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int)

scala> RowEncoder.encoder(0, 1, 2, 3)((is: Ints) => (is.i1, is.i2, is.i3, is.i4)).encode(Ints(1, 2, 3, 4))
res3: Seq[String] = Vector(1, 2, 3, 4)
```
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
f
encoding function.
Definition Classes
GeneratedRowEncoders
def encoder[C, A1, A2, A3](i1: Int, i2: Int, i3: Int)(f: (C) => (A1, A2, A3))(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3]): RowEncoder[C]
Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int)

scala> RowEncoder.encoder(0, 1, 2)((is: Ints) => (is.i1, is.i2, is.i3)).encode(Ints(1, 2, 3))
res2: Seq[String] = Vector(1, 2, 3)
```
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
f
encoding function.
Definition Classes
GeneratedRowEncoders
def encoder[C, A1, A2](i1: Int, i2: Int)(f: (C) => (A1, A2))(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2]): RowEncoder[C]
Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(i1: Int, i2: Int)

scala> RowEncoder.encoder(0, 1)((is: Ints) => (is.i1, is.i2)).encode(Ints(1, 2))
res1: Seq[String] = Vector(1, 2)
```
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
f
encoding function.
Definition Classes
GeneratedRowEncoders
def encoder[C, A1](f: (C) => A1)(implicit arg0: CellEncoder[A1]): RowEncoder[C]
Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(i1: Int)

scala> RowEncoder.encoder((is: Ints) => (is.i1)).encode(Ints(1))
res0: Seq[String] = List(1)
```
f
encoding function.
Definition Classes
GeneratedRowEncoders
final def eq(arg0: AnyRef): Boolean
Definition Classes
AnyRef
def equals(arg0: AnyRef): Boolean
Definition Classes
AnyRef → Any
def finalize(): Unit
Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.Throwable])
def from[D](f: (D) => Seq[String]): Encoder[Seq[String], D, codecs.type]
Definition Classes
EncoderCompanion
Annotations
@inline()
final def getClass(): Class[_ <: AnyRef]
Definition Classes
AnyRef → Any
Annotations
@native()
def hashCode(): Int
Definition Classes
AnyRef → Any
Annotations
@native()
final def isInstanceOf[T0]: Boolean
Definition Classes
Any
final def ne(arg0: AnyRef): Boolean
Definition Classes
AnyRef
final def notify(): Unit
Definition Classes
AnyRef
Annotations
@native()
final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@native()
def ordered[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 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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.ordered((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10, is.i11, is.i12, is.i13, is.i14, is.i15, is.i16, is.i17, is.i18, is.i19, is.i20, is.i21, is.i22)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22))
res21: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22)
```
Definition Classes
GeneratedRowEncoders
def ordered[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 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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.ordered((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10, is.i11, is.i12, is.i13, is.i14, is.i15, is.i16, is.i17, is.i18, is.i19, is.i20, is.i21)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21))
res20: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21)
```
Definition Classes
GeneratedRowEncoders
def ordered[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 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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.ordered((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10, is.i11, is.i12, is.i13, is.i14, is.i15, is.i16, is.i17, is.i18, is.i19, is.i20)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20))
res19: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)
```
Definition Classes
GeneratedRowEncoders
def ordered[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 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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.ordered((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10, is.i11, is.i12, is.i13, is.i14, is.i15, is.i16, is.i17, is.i18, is.i19)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19))
res18: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19)
```
Definition Classes
GeneratedRowEncoders
def ordered[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 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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.ordered((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10, is.i11, is.i12, is.i13, is.i14, is.i15, is.i16, is.i17, is.i18)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18))
res17: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18)
```
Definition Classes
GeneratedRowEncoders
def ordered[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 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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.ordered((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10, is.i11, is.i12, is.i13, is.i14, is.i15, is.i16, is.i17)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17))
res16: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17)
```
Definition Classes
GeneratedRowEncoders
def ordered[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 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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.ordered((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10, is.i11, is.i12, is.i13, is.i14, is.i15, is.i16)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16))
res15: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)
```
Definition Classes
GeneratedRowEncoders
def ordered[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 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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.ordered((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10, is.i11, is.i12, is.i13, is.i14, is.i15)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15))
res14: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
```
Definition Classes
GeneratedRowEncoders
def ordered[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 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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.ordered((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10, is.i11, is.i12, is.i13, is.i14)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14))
res13: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)
```
Definition Classes
GeneratedRowEncoders
def ordered[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 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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(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)

scala> RowEncoder.ordered((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10, is.i11, is.i12, is.i13)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13))
res12: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)
```
Definition Classes
GeneratedRowEncoders
def ordered[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 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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int, i12: Int)

scala> RowEncoder.ordered((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10, is.i11, is.i12)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12))
res11: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)
```
Definition Classes
GeneratedRowEncoders
def ordered[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 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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int)

scala> RowEncoder.ordered((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10, is.i11)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11))
res10: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)
```
Definition Classes
GeneratedRowEncoders
def ordered[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](f: (C) => (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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int)

scala> RowEncoder.ordered((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
res9: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
```
Definition Classes
GeneratedRowEncoders
def ordered[C, A1, A2, A3, A4, A5, A6, A7, A8, A9](f: (C) => (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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int)

scala> RowEncoder.ordered((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9))
res8: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8, 9)
```
Definition Classes
GeneratedRowEncoders
def ordered[C, A1, A2, A3, A4, A5, A6, A7, A8](f: (C) => (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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int)

scala> RowEncoder.ordered((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8)).encode(Ints(1, 2, 3, 4, 5, 6, 7, 8))
res7: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7, 8)
```
Definition Classes
GeneratedRowEncoders
def ordered[C, A1, A2, A3, A4, A5, A6, A7](f: (C) => (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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int)

scala> RowEncoder.ordered((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7)).encode(Ints(1, 2, 3, 4, 5, 6, 7))
res6: Seq[String] = Vector(1, 2, 3, 4, 5, 6, 7)
```
Definition Classes
GeneratedRowEncoders
def ordered[C, A1, A2, A3, A4, A5, A6](f: (C) => (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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int)

scala> RowEncoder.ordered((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6)).encode(Ints(1, 2, 3, 4, 5, 6))
res5: Seq[String] = Vector(1, 2, 3, 4, 5, 6)
```
Definition Classes
GeneratedRowEncoders
def ordered[C, A1, A2, A3, A4, A5](f: (C) => (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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int)

scala> RowEncoder.ordered((is: Ints) => (is.i1, is.i2, is.i3, is.i4, is.i5)).encode(Ints(1, 2, 3, 4, 5))
res4: Seq[String] = Vector(1, 2, 3, 4, 5)
```
Definition Classes
GeneratedRowEncoders
def ordered[C, A1, A2, A3, A4](f: (C) => (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 function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int)

scala> RowEncoder.ordered((is: Ints) => (is.i1, is.i2, is.i3, is.i4)).encode(Ints(1, 2, 3, 4))
res3: Seq[String] = Vector(1, 2, 3, 4)
```
Definition Classes
GeneratedRowEncoders
def ordered[C, A1, A2, A3](f: (C) => (A1, A2, A3))(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2], arg2: CellEncoder[A3]): RowEncoder[C]
Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int)

scala> RowEncoder.ordered((is: Ints) => (is.i1, is.i2, is.i3)).encode(Ints(1, 2, 3))
res2: Seq[String] = Vector(1, 2, 3)
```
Definition Classes
GeneratedRowEncoders
def ordered[C, A1, A2](f: (C) => (A1, A2))(implicit arg0: CellEncoder[A1], arg1: CellEncoder[A2]): RowEncoder[C]
Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(i1: Int, i2: Int)

scala> RowEncoder.ordered((is: Ints) => (is.i1, is.i2)).encode(Ints(1, 2))
res1: Seq[String] = Vector(1, 2)
```
Definition Classes
GeneratedRowEncoders
def ordered[C, A1](f: (C) => A1)(implicit arg0: CellEncoder[A1]): RowEncoder[C]
Creates a new RowEncoder from the specified function.
Creates a new RowEncoder from the specified function.
For example:
```
scala> case class Ints(i1: Int)

scala> RowEncoder.ordered((is: Ints) => (is.i1)).encode(Ints(1))
res0: Seq[String] = List(1)
```
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(classOf[java.lang.InterruptedException])
final def wait(arg0: Long, arg1: Int): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException])
final def wait(arg0: Long): Unit
Definition Classes
AnyRef
Annotations
@throws(classOf[java.lang.InterruptedException]) @native()

Packages

RowEncoder

object RowEncoder extends GeneratedRowEncoders with EncoderCompanion[Seq[String], codecs.type]

Value Members

Inherited from EncoderCompanion[Seq[String], codecs.type]

Inherited from GeneratedRowEncoders

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

RowEncoder

object RowEncoder extends GeneratedRowEncoders with EncoderCompanion[Seq[String], codecs.type]

Value Members

Inherited from EncoderCompanion[Seq[String], codecs.type]

Inherited from GeneratedRowEncoders

Inherited from AnyRef

Inherited from Any

Ungrouped

RowEncoder