GeneratedRowCodecs

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
final def asInstanceOf[T0]: T0

Definition Classes
Any
def caseCodec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22) ⇒ C)(g: (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: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16], arg32: CellEncoder[A17], arg33: CellDecoder[A17], arg34: CellEncoder[A18], arg35: CellDecoder[A18], arg36: CellEncoder[A19], arg37: CellDecoder[A19], arg38: CellEncoder[A20], arg39: CellDecoder[A20], arg40: CellEncoder[A21], arg41: CellDecoder[A21], arg42: CellEncoder[A22], arg43: CellDecoder[A22]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseCodec(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21)(Ints.apply _)(Ints.unapply _)

scala> codec.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] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22"))
res22: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22))
```
def caseCodec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) ⇒ C)(g: (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: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16], arg32: CellEncoder[A17], arg33: CellDecoder[A17], arg34: CellEncoder[A18], arg35: CellDecoder[A18], arg36: CellEncoder[A19], arg37: CellDecoder[A19], arg38: CellEncoder[A20], arg39: CellDecoder[A20], arg40: CellEncoder[A21], arg41: CellDecoder[A21]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseCodec(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)(Ints.apply _)(Ints.unapply _)

scala> codec.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] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21"))
res21: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21))
```
def caseCodec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) ⇒ C)(g: (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: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16], arg32: CellEncoder[A17], arg33: CellDecoder[A17], arg34: CellEncoder[A18], arg35: CellDecoder[A18], arg36: CellEncoder[A19], arg37: CellDecoder[A19], arg38: CellEncoder[A20], arg39: CellDecoder[A20]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseCodec(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19)(Ints.apply _)(Ints.unapply _)

scala> codec.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] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20"))
res20: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20))
```
def caseCodec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) ⇒ C)(g: (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: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16], arg32: CellEncoder[A17], arg33: CellDecoder[A17], arg34: CellEncoder[A18], arg35: CellDecoder[A18], arg36: CellEncoder[A19], arg37: CellDecoder[A19]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseCodec(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18)(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19))
res18: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19"))
res19: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19))
```
def caseCodec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) ⇒ C)(g: (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: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16], arg32: CellEncoder[A17], arg33: CellDecoder[A17], arg34: CellEncoder[A18], arg35: CellDecoder[A18]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseCodec(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17)(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18))
res17: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18"))
res18: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18))
```
def caseCodec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16], arg32: CellEncoder[A17], arg33: CellDecoder[A17]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseCodec(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17))
res16: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17"))
res17: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17))
```
def caseCodec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseCodec(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16))
res15: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16"))
res16: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16))
```
def caseCodec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseCodec(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15))
res14: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15"))
res15: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15))
```
def caseCodec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseCodec(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14))
res13: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14"))
res14: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14))
```
def caseCodec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseCodec(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13))
res12: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13"))
res13: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13))
```
def caseCodec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseCodec(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12))
res11: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"))
res12: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12))
```
def caseCodec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseCodec(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11))
res10: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11"))
res11: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11))
```
def caseCodec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseCodec(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
res9: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10"))
res10: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10))
```
def caseCodec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseCodec(0, 1, 2, 3, 4, 5, 6, 7, 8)(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9))
res8: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9"))
res9: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9))
```
def caseCodec[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: (A1, A2, A3, A4, A5, A6, A7, A8) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseCodec(0, 1, 2, 3, 4, 5, 6, 7)(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8))
res7: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8"))
res8: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8))
```
def caseCodec[C, A1, A2, A3, A4, A5, A6, A7](i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int)(f: (A1, A2, A3, A4, A5, A6, A7) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseCodec(0, 1, 2, 3, 4, 5, 6)(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7))
res6: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7"))
res7: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7))
```
def caseCodec[C, A1, A2, A3, A4, A5, A6](i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int)(f: (A1, A2, A3, A4, A5, A6) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseCodec(0, 1, 2, 3, 4, 5)(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6))
res5: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6"))
res6: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6))
```
def caseCodec[C, A1, A2, A3, A4, A5](i1: Int, i2: Int, i3: Int, i4: Int, i5: Int)(f: (A1, A2, A3, A4, A5) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4, A5)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec to call get on the return value.
For example
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int)

scala> val codec = RowCodec.caseCodec(0, 1, 2, 3, 4)(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5))
res4: Seq[String] = WrappedArray(1, 2, 3, 4, 5)

scala> codec.decode(Seq("1", "2", "3", "4", "5"))
res5: DecodeResult[Ints] = Success(Ints(1,2,3,4,5))
```
def caseCodec[C, A1, A2, A3, A4](i1: Int, i2: Int, i3: Int, i4: Int)(f: (A1, A2, A3, A4) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec to call get on the return value.
For example
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int)

scala> val codec = RowCodec.caseCodec(0, 1, 2, 3)(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4))
res3: Seq[String] = WrappedArray(1, 2, 3, 4)

scala> codec.decode(Seq("1", "2", "3", "4"))
res4: DecodeResult[Ints] = Success(Ints(1,2,3,4))
```
def caseCodec[C, A1, A2, A3](i1: Int, i2: Int, i3: Int)(f: (A1, A2, A3) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec to call get on the return value.
For example
```
scala> case class Ints(i1: Int, i2: Int, i3: Int)

scala> val codec = RowCodec.caseCodec(0, 1, 2)(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3))
res2: Seq[String] = WrappedArray(1, 2, 3)

scala> codec.decode(Seq("1", "2", "3"))
res3: DecodeResult[Ints] = Success(Ints(1,2,3))
```
def caseCodec[C, A1, A2](i1: Int, i2: Int)(f: (A1, A2) ⇒ C)(g: (C) ⇒ Option[(A1, A2)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec to call get on the return value.
For example
```
scala> case class Ints(i1: Int, i2: Int)

scala> val codec = RowCodec.caseCodec(0, 1)(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2))
res1: Seq[String] = WrappedArray(1, 2)

scala> codec.decode(Seq("1", "2"))
res2: DecodeResult[Ints] = Success(Ints(1,2))
```
def caseCodec[C, A1](f: (A1) ⇒ C)(g: (C) ⇒ Option[A1])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec to call get on the return value.
For example
```
scala> case class Ints(i1: Int)

scala> val codec = RowCodec.caseCodec(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1))
res0: Seq[String] = List(1)

scala> codec.decode(Seq("1"))
res1: DecodeResult[Ints] = Success(Ints(1))
```
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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22) ⇒ C)(g: (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: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16], arg32: CellEncoder[A17], arg33: CellDecoder[A17], arg34: CellEncoder[A18], arg35: CellDecoder[A18], arg36: CellEncoder[A19], arg37: CellDecoder[A19], arg38: CellEncoder[A20], arg39: CellDecoder[A20], arg40: CellEncoder[A21], arg41: CellDecoder[A21], arg42: CellEncoder[A22], arg43: CellDecoder[A22]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseOrdered(Ints.apply _)(Ints.unapply _)

scala> codec.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] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22"))
res22: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22))
```
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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) ⇒ C)(g: (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: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16], arg32: CellEncoder[A17], arg33: CellDecoder[A17], arg34: CellEncoder[A18], arg35: CellDecoder[A18], arg36: CellEncoder[A19], arg37: CellDecoder[A19], arg38: CellEncoder[A20], arg39: CellDecoder[A20], arg40: CellEncoder[A21], arg41: CellDecoder[A21]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseOrdered(Ints.apply _)(Ints.unapply _)

scala> codec.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] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21"))
res21: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21))
```
def caseOrdered[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) ⇒ C)(g: (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: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16], arg32: CellEncoder[A17], arg33: CellDecoder[A17], arg34: CellEncoder[A18], arg35: CellDecoder[A18], arg36: CellEncoder[A19], arg37: CellDecoder[A19], arg38: CellEncoder[A20], arg39: CellDecoder[A20]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseOrdered(Ints.apply _)(Ints.unapply _)

scala> codec.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] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20"))
res20: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20))
```
def caseOrdered[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) ⇒ C)(g: (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: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16], arg32: CellEncoder[A17], arg33: CellDecoder[A17], arg34: CellEncoder[A18], arg35: CellDecoder[A18], arg36: CellEncoder[A19], arg37: CellDecoder[A19]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseOrdered(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19))
res18: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19"))
res19: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19))
```
def caseOrdered[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) ⇒ C)(g: (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: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16], arg32: CellEncoder[A17], arg33: CellDecoder[A17], arg34: CellEncoder[A18], arg35: CellDecoder[A18]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseOrdered(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18))
res17: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18"))
res18: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18))
```
def caseOrdered[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16], arg32: CellEncoder[A17], arg33: CellDecoder[A17]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseOrdered(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17))
res16: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17"))
res17: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17))
```
def caseOrdered[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseOrdered(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16))
res15: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16"))
res16: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16))
```
def caseOrdered[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseOrdered(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15))
res14: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15"))
res15: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15))
```
def caseOrdered[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseOrdered(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14))
res13: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14"))
res14: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14))
```
def caseOrdered[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseOrdered(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13))
res12: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13"))
res13: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13))
```
def caseOrdered[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseOrdered(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12))
res11: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"))
res12: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12))
```
def caseOrdered[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseOrdered(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11))
res10: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11"))
res11: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11))
```
def caseOrdered[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseOrdered(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
res9: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10"))
res10: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10))
```
def caseOrdered[C, A1, A2, A3, A4, A5, A6, A7, A8, A9](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8, A9)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseOrdered(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9))
res8: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9"))
res9: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9))
```
def caseOrdered[C, A1, A2, A3, A4, A5, A6, A7, A8](f: (A1, A2, A3, A4, A5, A6, A7, A8) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7, A8)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseOrdered(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8))
res7: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8"))
res8: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8))
```
def caseOrdered[C, A1, A2, A3, A4, A5, A6, A7](f: (A1, A2, A3, A4, A5, A6, A7) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6, A7)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseOrdered(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7))
res6: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7"))
res7: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7))
```
def caseOrdered[C, A1, A2, A3, A4, A5, A6](f: (A1, A2, A3, A4, A5, A6) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4, A5, A6)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec 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> val codec = RowCodec.caseOrdered(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6))
res5: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6"))
res6: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6))
```
def caseOrdered[C, A1, A2, A3, A4, A5](f: (A1, A2, A3, A4, A5) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4, A5)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec to call get on the return value.
For example
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int)

scala> val codec = RowCodec.caseOrdered(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4, 5))
res4: Seq[String] = WrappedArray(1, 2, 3, 4, 5)

scala> codec.decode(Seq("1", "2", "3", "4", "5"))
res5: DecodeResult[Ints] = Success(Ints(1,2,3,4,5))
```
def caseOrdered[C, A1, A2, A3, A4](f: (A1, A2, A3, A4) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3, A4)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec to call get on the return value.
For example
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int)

scala> val codec = RowCodec.caseOrdered(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3, 4))
res3: Seq[String] = WrappedArray(1, 2, 3, 4)

scala> codec.decode(Seq("1", "2", "3", "4"))
res4: DecodeResult[Ints] = Success(Ints(1,2,3,4))
```
def caseOrdered[C, A1, A2, A3](f: (A1, A2, A3) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec to call get on the return value.
For example
```
scala> case class Ints(i1: Int, i2: Int, i3: Int)

scala> val codec = RowCodec.caseOrdered(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2, 3))
res2: Seq[String] = WrappedArray(1, 2, 3)

scala> codec.decode(Seq("1", "2", "3"))
res3: DecodeResult[Ints] = Success(Ints(1,2,3))
```
def caseOrdered[C, A1, A2](f: (A1, A2) ⇒ C)(g: (C) ⇒ Option[(A1, A2)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec to call get on the return value.
For example
```
scala> case class Ints(i1: Int, i2: Int)

scala> val codec = RowCodec.caseOrdered(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1, 2))
res1: Seq[String] = WrappedArray(1, 2)

scala> codec.decode(Seq("1", "2"))
res2: DecodeResult[Ints] = Success(Ints(1,2))
```
def caseOrdered[C, A1](f: (A1) ⇒ C)(g: (C) ⇒ Option[A1])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1]): RowCodec[C]

Creates a new RowCodec instance for the specified encoding and decoding functions.
Creates a new RowCodec instance for the specified encoding and decoding functions.
This is meant for case classes and is unsafe for any other type: a case class' unapply method never returns Some, which allows caseCodec to call get on the return value.
For example
```
scala> case class Ints(i1: Int)

scala> val codec = RowCodec.caseOrdered(Ints.apply _)(Ints.unapply _)

scala> codec.encode(Ints(1))
res0: Seq[String] = List(1)

scala> codec.decode(Seq("1"))
res1: DecodeResult[Ints] = Success(Ints(1))
```
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def codec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22) ⇒ C)(g: (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: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16], arg32: CellEncoder[A17], arg33: CellDecoder[A17], arg34: CellEncoder[A18], arg35: CellDecoder[A18], arg36: CellEncoder[A19], arg37: CellDecoder[A19], arg38: CellEncoder[A20], arg39: CellDecoder[A20], arg40: CellEncoder[A21], arg41: CellDecoder[A21], arg42: CellEncoder[A22], arg43: CellDecoder[A22]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.codec(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21)(Ints.apply _)((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))

scala> codec.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] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22"))
res22: DecodeResult[Ints] = Success(Ints(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 and will be at index 1 of the value returned by g
i2
index of the cell that should be passed as parameter number 2 of f and will be at index 2 of the value returned by g
i3
index of the cell that should be passed as parameter number 3 of f and will be at index 3 of the value returned by g
i4
index of the cell that should be passed as parameter number 4 of f and will be at index 4 of the value returned by g
i5
index of the cell that should be passed as parameter number 5 of f and will be at index 5 of the value returned by g
i6
index of the cell that should be passed as parameter number 6 of f and will be at index 6 of the value returned by g
i7
index of the cell that should be passed as parameter number 7 of f and will be at index 7 of the value returned by g
i8
index of the cell that should be passed as parameter number 8 of f and will be at index 8 of the value returned by g
i9
index of the cell that should be passed as parameter number 9 of f and will be at index 9 of the value returned by g
i10
index of the cell that should be passed as parameter number 10 of f and will be at index 10 of the value returned by g
i11
index of the cell that should be passed as parameter number 11 of f and will be at index 11 of the value returned by g
i12
index of the cell that should be passed as parameter number 12 of f and will be at index 12 of the value returned by g
i13
index of the cell that should be passed as parameter number 13 of f and will be at index 13 of the value returned by g
i14
index of the cell that should be passed as parameter number 14 of f and will be at index 14 of the value returned by g
i15
index of the cell that should be passed as parameter number 15 of f and will be at index 15 of the value returned by g
i16
index of the cell that should be passed as parameter number 16 of f and will be at index 16 of the value returned by g
i17
index of the cell that should be passed as parameter number 17 of f and will be at index 17 of the value returned by g
i18
index of the cell that should be passed as parameter number 18 of f and will be at index 18 of the value returned by g
i19
index of the cell that should be passed as parameter number 19 of f and will be at index 19 of the value returned by g
i20
index of the cell that should be passed as parameter number 20 of f and will be at index 20 of the value returned by g
i21
index of the cell that should be passed as parameter number 21 of f and will be at index 21 of the value returned by g
i22
index of the cell that should be passed as parameter number 22 of f and will be at index 22 of the value returned by g
f
encoding function.
g
decoding function.
def codec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) ⇒ C)(g: (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: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16], arg32: CellEncoder[A17], arg33: CellDecoder[A17], arg34: CellEncoder[A18], arg35: CellDecoder[A18], arg36: CellEncoder[A19], arg37: CellDecoder[A19], arg38: CellEncoder[A20], arg39: CellDecoder[A20], arg40: CellEncoder[A21], arg41: CellDecoder[A21]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.codec(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)(Ints.apply _)((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))

scala> codec.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] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21"))
res21: DecodeResult[Ints] = Success(Ints(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 and will be at index 1 of the value returned by g
i2
index of the cell that should be passed as parameter number 2 of f and will be at index 2 of the value returned by g
i3
index of the cell that should be passed as parameter number 3 of f and will be at index 3 of the value returned by g
i4
index of the cell that should be passed as parameter number 4 of f and will be at index 4 of the value returned by g
i5
index of the cell that should be passed as parameter number 5 of f and will be at index 5 of the value returned by g
i6
index of the cell that should be passed as parameter number 6 of f and will be at index 6 of the value returned by g
i7
index of the cell that should be passed as parameter number 7 of f and will be at index 7 of the value returned by g
i8
index of the cell that should be passed as parameter number 8 of f and will be at index 8 of the value returned by g
i9
index of the cell that should be passed as parameter number 9 of f and will be at index 9 of the value returned by g
i10
index of the cell that should be passed as parameter number 10 of f and will be at index 10 of the value returned by g
i11
index of the cell that should be passed as parameter number 11 of f and will be at index 11 of the value returned by g
i12
index of the cell that should be passed as parameter number 12 of f and will be at index 12 of the value returned by g
i13
index of the cell that should be passed as parameter number 13 of f and will be at index 13 of the value returned by g
i14
index of the cell that should be passed as parameter number 14 of f and will be at index 14 of the value returned by g
i15
index of the cell that should be passed as parameter number 15 of f and will be at index 15 of the value returned by g
i16
index of the cell that should be passed as parameter number 16 of f and will be at index 16 of the value returned by g
i17
index of the cell that should be passed as parameter number 17 of f and will be at index 17 of the value returned by g
i18
index of the cell that should be passed as parameter number 18 of f and will be at index 18 of the value returned by g
i19
index of the cell that should be passed as parameter number 19 of f and will be at index 19 of the value returned by g
i20
index of the cell that should be passed as parameter number 20 of f and will be at index 20 of the value returned by g
i21
index of the cell that should be passed as parameter number 21 of f and will be at index 21 of the value returned by g
f
encoding function.
g
decoding function.
def codec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) ⇒ C)(g: (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: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16], arg32: CellEncoder[A17], arg33: CellDecoder[A17], arg34: CellEncoder[A18], arg35: CellDecoder[A18], arg36: CellEncoder[A19], arg37: CellDecoder[A19], arg38: CellEncoder[A20], arg39: CellDecoder[A20]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.codec(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19)(Ints.apply _)((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))

scala> codec.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] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20"))
res20: DecodeResult[Ints] = Success(Ints(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 and will be at index 1 of the value returned by g
i2
index of the cell that should be passed as parameter number 2 of f and will be at index 2 of the value returned by g
i3
index of the cell that should be passed as parameter number 3 of f and will be at index 3 of the value returned by g
i4
index of the cell that should be passed as parameter number 4 of f and will be at index 4 of the value returned by g
i5
index of the cell that should be passed as parameter number 5 of f and will be at index 5 of the value returned by g
i6
index of the cell that should be passed as parameter number 6 of f and will be at index 6 of the value returned by g
i7
index of the cell that should be passed as parameter number 7 of f and will be at index 7 of the value returned by g
i8
index of the cell that should be passed as parameter number 8 of f and will be at index 8 of the value returned by g
i9
index of the cell that should be passed as parameter number 9 of f and will be at index 9 of the value returned by g
i10
index of the cell that should be passed as parameter number 10 of f and will be at index 10 of the value returned by g
i11
index of the cell that should be passed as parameter number 11 of f and will be at index 11 of the value returned by g
i12
index of the cell that should be passed as parameter number 12 of f and will be at index 12 of the value returned by g
i13
index of the cell that should be passed as parameter number 13 of f and will be at index 13 of the value returned by g
i14
index of the cell that should be passed as parameter number 14 of f and will be at index 14 of the value returned by g
i15
index of the cell that should be passed as parameter number 15 of f and will be at index 15 of the value returned by g
i16
index of the cell that should be passed as parameter number 16 of f and will be at index 16 of the value returned by g
i17
index of the cell that should be passed as parameter number 17 of f and will be at index 17 of the value returned by g
i18
index of the cell that should be passed as parameter number 18 of f and will be at index 18 of the value returned by g
i19
index of the cell that should be passed as parameter number 19 of f and will be at index 19 of the value returned by g
i20
index of the cell that should be passed as parameter number 20 of f and will be at index 20 of the value returned by g
f
encoding function.
g
decoding function.
def codec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) ⇒ C)(g: (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: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16], arg32: CellEncoder[A17], arg33: CellDecoder[A17], arg34: CellEncoder[A18], arg35: CellDecoder[A18], arg36: CellEncoder[A19], arg37: CellDecoder[A19]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.codec(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18)(Ints.apply _)((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))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19))
res18: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19"))
res19: DecodeResult[Ints] = Success(Ints(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 and will be at index 1 of the value returned by g
i2
index of the cell that should be passed as parameter number 2 of f and will be at index 2 of the value returned by g
i3
index of the cell that should be passed as parameter number 3 of f and will be at index 3 of the value returned by g
i4
index of the cell that should be passed as parameter number 4 of f and will be at index 4 of the value returned by g
i5
index of the cell that should be passed as parameter number 5 of f and will be at index 5 of the value returned by g
i6
index of the cell that should be passed as parameter number 6 of f and will be at index 6 of the value returned by g
i7
index of the cell that should be passed as parameter number 7 of f and will be at index 7 of the value returned by g
i8
index of the cell that should be passed as parameter number 8 of f and will be at index 8 of the value returned by g
i9
index of the cell that should be passed as parameter number 9 of f and will be at index 9 of the value returned by g
i10
index of the cell that should be passed as parameter number 10 of f and will be at index 10 of the value returned by g
i11
index of the cell that should be passed as parameter number 11 of f and will be at index 11 of the value returned by g
i12
index of the cell that should be passed as parameter number 12 of f and will be at index 12 of the value returned by g
i13
index of the cell that should be passed as parameter number 13 of f and will be at index 13 of the value returned by g
i14
index of the cell that should be passed as parameter number 14 of f and will be at index 14 of the value returned by g
i15
index of the cell that should be passed as parameter number 15 of f and will be at index 15 of the value returned by g
i16
index of the cell that should be passed as parameter number 16 of f and will be at index 16 of the value returned by g
i17
index of the cell that should be passed as parameter number 17 of f and will be at index 17 of the value returned by g
i18
index of the cell that should be passed as parameter number 18 of f and will be at index 18 of the value returned by g
i19
index of the cell that should be passed as parameter number 19 of f and will be at index 19 of the value returned by g
f
encoding function.
g
decoding function.
def codec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16], arg32: CellEncoder[A17], arg33: CellDecoder[A17], arg34: CellEncoder[A18], arg35: CellDecoder[A18]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.codec(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17)(Ints.apply _)((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))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18))
res17: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18"))
res18: DecodeResult[Ints] = Success(Ints(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 and will be at index 1 of the value returned by g
i2
index of the cell that should be passed as parameter number 2 of f and will be at index 2 of the value returned by g
i3
index of the cell that should be passed as parameter number 3 of f and will be at index 3 of the value returned by g
i4
index of the cell that should be passed as parameter number 4 of f and will be at index 4 of the value returned by g
i5
index of the cell that should be passed as parameter number 5 of f and will be at index 5 of the value returned by g
i6
index of the cell that should be passed as parameter number 6 of f and will be at index 6 of the value returned by g
i7
index of the cell that should be passed as parameter number 7 of f and will be at index 7 of the value returned by g
i8
index of the cell that should be passed as parameter number 8 of f and will be at index 8 of the value returned by g
i9
index of the cell that should be passed as parameter number 9 of f and will be at index 9 of the value returned by g
i10
index of the cell that should be passed as parameter number 10 of f and will be at index 10 of the value returned by g
i11
index of the cell that should be passed as parameter number 11 of f and will be at index 11 of the value returned by g
i12
index of the cell that should be passed as parameter number 12 of f and will be at index 12 of the value returned by g
i13
index of the cell that should be passed as parameter number 13 of f and will be at index 13 of the value returned by g
i14
index of the cell that should be passed as parameter number 14 of f and will be at index 14 of the value returned by g
i15
index of the cell that should be passed as parameter number 15 of f and will be at index 15 of the value returned by g
i16
index of the cell that should be passed as parameter number 16 of f and will be at index 16 of the value returned by g
i17
index of the cell that should be passed as parameter number 17 of f and will be at index 17 of the value returned by g
i18
index of the cell that should be passed as parameter number 18 of f and will be at index 18 of the value returned by g
f
encoding function.
g
decoding function.
def codec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16], arg32: CellEncoder[A17], arg33: CellDecoder[A17]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.codec(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)(Ints.apply _)((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))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17))
res16: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17"))
res17: DecodeResult[Ints] = Success(Ints(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 and will be at index 1 of the value returned by g
i2
index of the cell that should be passed as parameter number 2 of f and will be at index 2 of the value returned by g
i3
index of the cell that should be passed as parameter number 3 of f and will be at index 3 of the value returned by g
i4
index of the cell that should be passed as parameter number 4 of f and will be at index 4 of the value returned by g
i5
index of the cell that should be passed as parameter number 5 of f and will be at index 5 of the value returned by g
i6
index of the cell that should be passed as parameter number 6 of f and will be at index 6 of the value returned by g
i7
index of the cell that should be passed as parameter number 7 of f and will be at index 7 of the value returned by g
i8
index of the cell that should be passed as parameter number 8 of f and will be at index 8 of the value returned by g
i9
index of the cell that should be passed as parameter number 9 of f and will be at index 9 of the value returned by g
i10
index of the cell that should be passed as parameter number 10 of f and will be at index 10 of the value returned by g
i11
index of the cell that should be passed as parameter number 11 of f and will be at index 11 of the value returned by g
i12
index of the cell that should be passed as parameter number 12 of f and will be at index 12 of the value returned by g
i13
index of the cell that should be passed as parameter number 13 of f and will be at index 13 of the value returned by g
i14
index of the cell that should be passed as parameter number 14 of f and will be at index 14 of the value returned by g
i15
index of the cell that should be passed as parameter number 15 of f and will be at index 15 of the value returned by g
i16
index of the cell that should be passed as parameter number 16 of f and will be at index 16 of the value returned by g
i17
index of the cell that should be passed as parameter number 17 of f and will be at index 17 of the value returned by g
f
encoding function.
g
decoding function.
def codec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.codec(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)(Ints.apply _)((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))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16))
res15: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16"))
res16: DecodeResult[Ints] = Success(Ints(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 and will be at index 1 of the value returned by g
i2
index of the cell that should be passed as parameter number 2 of f and will be at index 2 of the value returned by g
i3
index of the cell that should be passed as parameter number 3 of f and will be at index 3 of the value returned by g
i4
index of the cell that should be passed as parameter number 4 of f and will be at index 4 of the value returned by g
i5
index of the cell that should be passed as parameter number 5 of f and will be at index 5 of the value returned by g
i6
index of the cell that should be passed as parameter number 6 of f and will be at index 6 of the value returned by g
i7
index of the cell that should be passed as parameter number 7 of f and will be at index 7 of the value returned by g
i8
index of the cell that should be passed as parameter number 8 of f and will be at index 8 of the value returned by g
i9
index of the cell that should be passed as parameter number 9 of f and will be at index 9 of the value returned by g
i10
index of the cell that should be passed as parameter number 10 of f and will be at index 10 of the value returned by g
i11
index of the cell that should be passed as parameter number 11 of f and will be at index 11 of the value returned by g
i12
index of the cell that should be passed as parameter number 12 of f and will be at index 12 of the value returned by g
i13
index of the cell that should be passed as parameter number 13 of f and will be at index 13 of the value returned by g
i14
index of the cell that should be passed as parameter number 14 of f and will be at index 14 of the value returned by g
i15
index of the cell that should be passed as parameter number 15 of f and will be at index 15 of the value returned by g
i16
index of the cell that should be passed as parameter number 16 of f and will be at index 16 of the value returned by g
f
encoding function.
g
decoding function.
def codec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.codec(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)(Ints.apply _)((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))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15))
res14: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15"))
res15: DecodeResult[Ints] = Success(Ints(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 and will be at index 1 of the value returned by g
i2
index of the cell that should be passed as parameter number 2 of f and will be at index 2 of the value returned by g
i3
index of the cell that should be passed as parameter number 3 of f and will be at index 3 of the value returned by g
i4
index of the cell that should be passed as parameter number 4 of f and will be at index 4 of the value returned by g
i5
index of the cell that should be passed as parameter number 5 of f and will be at index 5 of the value returned by g
i6
index of the cell that should be passed as parameter number 6 of f and will be at index 6 of the value returned by g
i7
index of the cell that should be passed as parameter number 7 of f and will be at index 7 of the value returned by g
i8
index of the cell that should be passed as parameter number 8 of f and will be at index 8 of the value returned by g
i9
index of the cell that should be passed as parameter number 9 of f and will be at index 9 of the value returned by g
i10
index of the cell that should be passed as parameter number 10 of f and will be at index 10 of the value returned by g
i11
index of the cell that should be passed as parameter number 11 of f and will be at index 11 of the value returned by g
i12
index of the cell that should be passed as parameter number 12 of f and will be at index 12 of the value returned by g
i13
index of the cell that should be passed as parameter number 13 of f and will be at index 13 of the value returned by g
i14
index of the cell that should be passed as parameter number 14 of f and will be at index 14 of the value returned by g
i15
index of the cell that should be passed as parameter number 15 of f and will be at index 15 of the value returned by g
f
encoding function.
g
decoding function.
def codec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.codec(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)(Ints.apply _)((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))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14))
res13: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14"))
res14: DecodeResult[Ints] = Success(Ints(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 and will be at index 1 of the value returned by g
i2
index of the cell that should be passed as parameter number 2 of f and will be at index 2 of the value returned by g
i3
index of the cell that should be passed as parameter number 3 of f and will be at index 3 of the value returned by g
i4
index of the cell that should be passed as parameter number 4 of f and will be at index 4 of the value returned by g
i5
index of the cell that should be passed as parameter number 5 of f and will be at index 5 of the value returned by g
i6
index of the cell that should be passed as parameter number 6 of f and will be at index 6 of the value returned by g
i7
index of the cell that should be passed as parameter number 7 of f and will be at index 7 of the value returned by g
i8
index of the cell that should be passed as parameter number 8 of f and will be at index 8 of the value returned by g
i9
index of the cell that should be passed as parameter number 9 of f and will be at index 9 of the value returned by g
i10
index of the cell that should be passed as parameter number 10 of f and will be at index 10 of the value returned by g
i11
index of the cell that should be passed as parameter number 11 of f and will be at index 11 of the value returned by g
i12
index of the cell that should be passed as parameter number 12 of f and will be at index 12 of the value returned by g
i13
index of the cell that should be passed as parameter number 13 of f and will be at index 13 of the value returned by g
i14
index of the cell that should be passed as parameter number 14 of f and will be at index 14 of the value returned by g
f
encoding function.
g
decoding function.
def codec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.codec(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)(Ints.apply _)((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))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13))
res12: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13"))
res13: DecodeResult[Ints] = Success(Ints(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 and will be at index 1 of the value returned by g
i2
index of the cell that should be passed as parameter number 2 of f and will be at index 2 of the value returned by g
i3
index of the cell that should be passed as parameter number 3 of f and will be at index 3 of the value returned by g
i4
index of the cell that should be passed as parameter number 4 of f and will be at index 4 of the value returned by g
i5
index of the cell that should be passed as parameter number 5 of f and will be at index 5 of the value returned by g
i6
index of the cell that should be passed as parameter number 6 of f and will be at index 6 of the value returned by g
i7
index of the cell that should be passed as parameter number 7 of f and will be at index 7 of the value returned by g
i8
index of the cell that should be passed as parameter number 8 of f and will be at index 8 of the value returned by g
i9
index of the cell that should be passed as parameter number 9 of f and will be at index 9 of the value returned by g
i10
index of the cell that should be passed as parameter number 10 of f and will be at index 10 of the value returned by g
i11
index of the cell that should be passed as parameter number 11 of f and will be at index 11 of the value returned by g
i12
index of the cell that should be passed as parameter number 12 of f and will be at index 12 of the value returned by g
i13
index of the cell that should be passed as parameter number 13 of f and will be at index 13 of the value returned by g
f
encoding function.
g
decoding function.
def codec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.codec(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)(Ints.apply _)((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))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12))
res11: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"))
res12: DecodeResult[Ints] = Success(Ints(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 and will be at index 1 of the value returned by g
i2
index of the cell that should be passed as parameter number 2 of f and will be at index 2 of the value returned by g
i3
index of the cell that should be passed as parameter number 3 of f and will be at index 3 of the value returned by g
i4
index of the cell that should be passed as parameter number 4 of f and will be at index 4 of the value returned by g
i5
index of the cell that should be passed as parameter number 5 of f and will be at index 5 of the value returned by g
i6
index of the cell that should be passed as parameter number 6 of f and will be at index 6 of the value returned by g
i7
index of the cell that should be passed as parameter number 7 of f and will be at index 7 of the value returned by g
i8
index of the cell that should be passed as parameter number 8 of f and will be at index 8 of the value returned by g
i9
index of the cell that should be passed as parameter number 9 of f and will be at index 9 of the value returned by g
i10
index of the cell that should be passed as parameter number 10 of f and will be at index 10 of the value returned by g
i11
index of the cell that should be passed as parameter number 11 of f and will be at index 11 of the value returned by g
i12
index of the cell that should be passed as parameter number 12 of f and will be at index 12 of the value returned by g
f
encoding function.
g
decoding function.
def codec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.codec(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)(Ints.apply _)((is: Ints) ⇒ (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10, is.i11))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11))
res10: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11"))
res11: DecodeResult[Ints] = Success(Ints(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 and will be at index 1 of the value returned by g
i2
index of the cell that should be passed as parameter number 2 of f and will be at index 2 of the value returned by g
i3
index of the cell that should be passed as parameter number 3 of f and will be at index 3 of the value returned by g
i4
index of the cell that should be passed as parameter number 4 of f and will be at index 4 of the value returned by g
i5
index of the cell that should be passed as parameter number 5 of f and will be at index 5 of the value returned by g
i6
index of the cell that should be passed as parameter number 6 of f and will be at index 6 of the value returned by g
i7
index of the cell that should be passed as parameter number 7 of f and will be at index 7 of the value returned by g
i8
index of the cell that should be passed as parameter number 8 of f and will be at index 8 of the value returned by g
i9
index of the cell that should be passed as parameter number 9 of f and will be at index 9 of the value returned by g
i10
index of the cell that should be passed as parameter number 10 of f and will be at index 10 of the value returned by g
i11
index of the cell that should be passed as parameter number 11 of f and will be at index 11 of the value returned by g
f
encoding function.
g
decoding function.
def codec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.codec(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)(Ints.apply _)((is: Ints) ⇒ (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
res9: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10"))
res10: DecodeResult[Ints] = Success(Ints(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 and will be at index 1 of the value returned by g
i2
index of the cell that should be passed as parameter number 2 of f and will be at index 2 of the value returned by g
i3
index of the cell that should be passed as parameter number 3 of f and will be at index 3 of the value returned by g
i4
index of the cell that should be passed as parameter number 4 of f and will be at index 4 of the value returned by g
i5
index of the cell that should be passed as parameter number 5 of f and will be at index 5 of the value returned by g
i6
index of the cell that should be passed as parameter number 6 of f and will be at index 6 of the value returned by g
i7
index of the cell that should be passed as parameter number 7 of f and will be at index 7 of the value returned by g
i8
index of the cell that should be passed as parameter number 8 of f and will be at index 8 of the value returned by g
i9
index of the cell that should be passed as parameter number 9 of f and will be at index 9 of the value returned by g
i10
index of the cell that should be passed as parameter number 10 of f and will be at index 10 of the value returned by g
f
encoding function.
g
decoding function.
def codec[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: (A1, A2, A3, A4, A5, A6, A7, A8, A9) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.codec(0, 1, 2, 3, 4, 5, 6, 7, 8)(Ints.apply _)((is: Ints) ⇒ (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9))
res8: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9"))
res9: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9))
```
i1
index of the cell that should be passed as parameter number 1 of f and will be at index 1 of the value returned by g
i2
index of the cell that should be passed as parameter number 2 of f and will be at index 2 of the value returned by g
i3
index of the cell that should be passed as parameter number 3 of f and will be at index 3 of the value returned by g
i4
index of the cell that should be passed as parameter number 4 of f and will be at index 4 of the value returned by g
i5
index of the cell that should be passed as parameter number 5 of f and will be at index 5 of the value returned by g
i6
index of the cell that should be passed as parameter number 6 of f and will be at index 6 of the value returned by g
i7
index of the cell that should be passed as parameter number 7 of f and will be at index 7 of the value returned by g
i8
index of the cell that should be passed as parameter number 8 of f and will be at index 8 of the value returned by g
i9
index of the cell that should be passed as parameter number 9 of f and will be at index 9 of the value returned by g
f
encoding function.
g
decoding function.
def codec[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: (A1, A2, A3, A4, A5, A6, A7, A8) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int)

scala> val codec = RowCodec.codec(0, 1, 2, 3, 4, 5, 6, 7)(Ints.apply _)((is: Ints) ⇒ (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8))
res7: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8"))
res8: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8))
```
i1
index of the cell that should be passed as parameter number 1 of f and will be at index 1 of the value returned by g
i2
index of the cell that should be passed as parameter number 2 of f and will be at index 2 of the value returned by g
i3
index of the cell that should be passed as parameter number 3 of f and will be at index 3 of the value returned by g
i4
index of the cell that should be passed as parameter number 4 of f and will be at index 4 of the value returned by g
i5
index of the cell that should be passed as parameter number 5 of f and will be at index 5 of the value returned by g
i6
index of the cell that should be passed as parameter number 6 of f and will be at index 6 of the value returned by g
i7
index of the cell that should be passed as parameter number 7 of f and will be at index 7 of the value returned by g
i8
index of the cell that should be passed as parameter number 8 of f and will be at index 8 of the value returned by g
f
encoding function.
g
decoding function.
def codec[C, A1, A2, A3, A4, A5, A6, A7](i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int)(f: (A1, A2, A3, A4, A5, A6, A7) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int)

scala> val codec = RowCodec.codec(0, 1, 2, 3, 4, 5, 6)(Ints.apply _)((is: Ints) ⇒ (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7))
res6: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7"))
res7: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7))
```
i1
index of the cell that should be passed as parameter number 1 of f and will be at index 1 of the value returned by g
i2
index of the cell that should be passed as parameter number 2 of f and will be at index 2 of the value returned by g
i3
index of the cell that should be passed as parameter number 3 of f and will be at index 3 of the value returned by g
i4
index of the cell that should be passed as parameter number 4 of f and will be at index 4 of the value returned by g
i5
index of the cell that should be passed as parameter number 5 of f and will be at index 5 of the value returned by g
i6
index of the cell that should be passed as parameter number 6 of f and will be at index 6 of the value returned by g
i7
index of the cell that should be passed as parameter number 7 of f and will be at index 7 of the value returned by g
f
encoding function.
g
decoding function.
def codec[C, A1, A2, A3, A4, A5, A6](i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int)(f: (A1, A2, A3, A4, A5, A6) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5, A6))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int)

scala> val codec = RowCodec.codec(0, 1, 2, 3, 4, 5)(Ints.apply _)((is: Ints) ⇒ (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6))
res5: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6"))
res6: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6))
```
i1
index of the cell that should be passed as parameter number 1 of f and will be at index 1 of the value returned by g
i2
index of the cell that should be passed as parameter number 2 of f and will be at index 2 of the value returned by g
i3
index of the cell that should be passed as parameter number 3 of f and will be at index 3 of the value returned by g
i4
index of the cell that should be passed as parameter number 4 of f and will be at index 4 of the value returned by g
i5
index of the cell that should be passed as parameter number 5 of f and will be at index 5 of the value returned by g
i6
index of the cell that should be passed as parameter number 6 of f and will be at index 6 of the value returned by g
f
encoding function.
g
decoding function.
def codec[C, A1, A2, A3, A4, A5](i1: Int, i2: Int, i3: Int, i4: Int, i5: Int)(f: (A1, A2, A3, A4, A5) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int)

scala> val codec = RowCodec.codec(0, 1, 2, 3, 4)(Ints.apply _)((is: Ints) ⇒ (is.i1, is.i2, is.i3, is.i4, is.i5))

scala> codec.encode(Ints(1, 2, 3, 4, 5))
res4: Seq[String] = WrappedArray(1, 2, 3, 4, 5)

scala> codec.decode(Seq("1", "2", "3", "4", "5"))
res5: DecodeResult[Ints] = Success(Ints(1,2,3,4,5))
```
i1
index of the cell that should be passed as parameter number 1 of f and will be at index 1 of the value returned by g
i2
index of the cell that should be passed as parameter number 2 of f and will be at index 2 of the value returned by g
i3
index of the cell that should be passed as parameter number 3 of f and will be at index 3 of the value returned by g
i4
index of the cell that should be passed as parameter number 4 of f and will be at index 4 of the value returned by g
i5
index of the cell that should be passed as parameter number 5 of f and will be at index 5 of the value returned by g
f
encoding function.
g
decoding function.
def codec[C, A1, A2, A3, A4](i1: Int, i2: Int, i3: Int, i4: Int)(f: (A1, A2, A3, A4) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int)

scala> val codec = RowCodec.codec(0, 1, 2, 3)(Ints.apply _)((is: Ints) ⇒ (is.i1, is.i2, is.i3, is.i4))

scala> codec.encode(Ints(1, 2, 3, 4))
res3: Seq[String] = WrappedArray(1, 2, 3, 4)

scala> codec.decode(Seq("1", "2", "3", "4"))
res4: DecodeResult[Ints] = Success(Ints(1,2,3,4))
```
i1
index of the cell that should be passed as parameter number 1 of f and will be at index 1 of the value returned by g
i2
index of the cell that should be passed as parameter number 2 of f and will be at index 2 of the value returned by g
i3
index of the cell that should be passed as parameter number 3 of f and will be at index 3 of the value returned by g
i4
index of the cell that should be passed as parameter number 4 of f and will be at index 4 of the value returned by g
f
encoding function.
g
decoding function.
def codec[C, A1, A2, A3](i1: Int, i2: Int, i3: Int)(f: (A1, A2, A3) ⇒ C)(g: (C) ⇒ (A1, A2, A3))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int)

scala> val codec = RowCodec.codec(0, 1, 2)(Ints.apply _)((is: Ints) ⇒ (is.i1, is.i2, is.i3))

scala> codec.encode(Ints(1, 2, 3))
res2: Seq[String] = WrappedArray(1, 2, 3)

scala> codec.decode(Seq("1", "2", "3"))
res3: DecodeResult[Ints] = Success(Ints(1,2,3))
```
i1
index of the cell that should be passed as parameter number 1 of f and will be at index 1 of the value returned by g
i2
index of the cell that should be passed as parameter number 2 of f and will be at index 2 of the value returned by g
i3
index of the cell that should be passed as parameter number 3 of f and will be at index 3 of the value returned by g
f
encoding function.
g
decoding function.
def codec[C, A1, A2](i1: Int, i2: Int)(f: (A1, A2) ⇒ C)(g: (C) ⇒ (A1, A2))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
For example:
```
scala> case class Ints(i1: Int, i2: Int)

scala> val codec = RowCodec.codec(0, 1)(Ints.apply _)((is: Ints) ⇒ (is.i1, is.i2))

scala> codec.encode(Ints(1, 2))
res1: Seq[String] = WrappedArray(1, 2)

scala> codec.decode(Seq("1", "2"))
res2: DecodeResult[Ints] = Success(Ints(1,2))
```
i1
index of the cell that should be passed as parameter number 1 of f and will be at index 1 of the value returned by g
i2
index of the cell that should be passed as parameter number 2 of f and will be at index 2 of the value returned by g
f
encoding function.
g
decoding function.
def codec[C, A1](f: (A1) ⇒ C)(g: (C) ⇒ A1)(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
For example:
```
scala> case class Ints(i1: Int)

scala> val codec = RowCodec.codec(Ints.apply _)((is: Ints) ⇒ (is.i1))

scala> codec.encode(Ints(1))
res0: Seq[String] = List(1)

scala> codec.decode(Seq("1"))
res1: DecodeResult[Ints] = Success(Ints(1))
```
final def eq(arg0: AnyRef): Boolean

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

Definition Classes
AnyRef → Any
def finalize(): Unit

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

Definition Classes
AnyRef → Any
def hashCode(): Int

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

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

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def 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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22) ⇒ C)(g: (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: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16], arg32: CellEncoder[A17], arg33: CellDecoder[A17], arg34: CellEncoder[A18], arg35: CellDecoder[A18], arg36: CellEncoder[A19], arg37: CellDecoder[A19], arg38: CellEncoder[A20], arg39: CellDecoder[A20], arg40: CellEncoder[A21], arg41: CellDecoder[A21], arg42: CellEncoder[A22], arg43: CellDecoder[A22]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.ordered(Ints.apply _)((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))

scala> codec.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] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22"))
res22: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22))
```
f
encoding function.
g
decoding function. ]
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: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) ⇒ C)(g: (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: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16], arg32: CellEncoder[A17], arg33: CellDecoder[A17], arg34: CellEncoder[A18], arg35: CellDecoder[A18], arg36: CellEncoder[A19], arg37: CellDecoder[A19], arg38: CellEncoder[A20], arg39: CellDecoder[A20], arg40: CellEncoder[A21], arg41: CellDecoder[A21]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.ordered(Ints.apply _)((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))

scala> codec.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] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21"))
res21: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21))
```
f
encoding function.
g
decoding function. ]
def ordered[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) ⇒ C)(g: (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: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16], arg32: CellEncoder[A17], arg33: CellDecoder[A17], arg34: CellEncoder[A18], arg35: CellDecoder[A18], arg36: CellEncoder[A19], arg37: CellDecoder[A19], arg38: CellEncoder[A20], arg39: CellDecoder[A20]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.ordered(Ints.apply _)((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))

scala> codec.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] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20"))
res20: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20))
```
f
encoding function.
g
decoding function. ]
def ordered[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) ⇒ C)(g: (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: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16], arg32: CellEncoder[A17], arg33: CellDecoder[A17], arg34: CellEncoder[A18], arg35: CellDecoder[A18], arg36: CellEncoder[A19], arg37: CellDecoder[A19]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.ordered(Ints.apply _)((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))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19))
res18: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19"))
res19: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19))
```
f
encoding function.
g
decoding function. ]
def ordered[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16], arg32: CellEncoder[A17], arg33: CellDecoder[A17], arg34: CellEncoder[A18], arg35: CellDecoder[A18]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.ordered(Ints.apply _)((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))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18))
res17: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18"))
res18: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18))
```
f
encoding function.
g
decoding function. ]
def ordered[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16], arg32: CellEncoder[A17], arg33: CellDecoder[A17]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.ordered(Ints.apply _)((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))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17))
res16: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17"))
res17: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17))
```
f
encoding function.
g
decoding function. ]
def ordered[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15], arg30: CellEncoder[A16], arg31: CellDecoder[A16]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.ordered(Ints.apply _)((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))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16))
res15: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16"))
res16: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16))
```
f
encoding function.
g
decoding function. ]
def ordered[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14], arg28: CellEncoder[A15], arg29: CellDecoder[A15]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.ordered(Ints.apply _)((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))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15))
res14: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15"))
res15: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15))
```
f
encoding function.
g
decoding function. ]
def ordered[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13], arg26: CellEncoder[A14], arg27: CellDecoder[A14]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.ordered(Ints.apply _)((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))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14))
res13: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14"))
res14: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13,14))
```
f
encoding function.
g
decoding function. ]
def ordered[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12], arg24: CellEncoder[A13], arg25: CellDecoder[A13]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.ordered(Ints.apply _)((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))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13))
res12: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13"))
res13: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12,13))
```
f
encoding function.
g
decoding function. ]
def ordered[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11], arg22: CellEncoder[A12], arg23: CellDecoder[A12]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.ordered(Ints.apply _)((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))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12))
res11: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"))
res12: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11,12))
```
f
encoding function.
g
decoding function. ]
def ordered[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10], arg20: CellEncoder[A11], arg21: CellDecoder[A11]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.ordered(Ints.apply _)((is: Ints) ⇒ (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10, is.i11))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11))
res10: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11"))
res11: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10,11))
```
f
encoding function.
g
decoding function. ]
def ordered[C, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9], arg18: CellEncoder[A10], arg19: CellDecoder[A10]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.ordered(Ints.apply _)((is: Ints) ⇒ (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9, is.i10))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
res9: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9", "10"))
res10: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9,10))
```
f
encoding function.
g
decoding function. ]
def ordered[C, A1, A2, A3, A4, A5, A6, A7, A8, A9](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8, A9))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8], arg16: CellEncoder[A9], arg17: CellDecoder[A9]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
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> val codec = RowCodec.ordered(Ints.apply _)((is: Ints) ⇒ (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8, is.i9))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8, 9))
res8: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8", "9"))
res9: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8,9))
```
f
encoding function.
g
decoding function. ]
def ordered[C, A1, A2, A3, A4, A5, A6, A7, A8](f: (A1, A2, A3, A4, A5, A6, A7, A8) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7, A8))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7], arg14: CellEncoder[A8], arg15: CellDecoder[A8]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int)

scala> val codec = RowCodec.ordered(Ints.apply _)((is: Ints) ⇒ (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7, is.i8))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7, 8))
res7: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7, 8)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7", "8"))
res8: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7,8))
```
f
encoding function.
g
decoding function. ]
def ordered[C, A1, A2, A3, A4, A5, A6, A7](f: (A1, A2, A3, A4, A5, A6, A7) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5, A6, A7))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6], arg12: CellEncoder[A7], arg13: CellDecoder[A7]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int)

scala> val codec = RowCodec.ordered(Ints.apply _)((is: Ints) ⇒ (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6, is.i7))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6, 7))
res6: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6, 7)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6", "7"))
res7: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6,7))
```
f
encoding function.
g
decoding function. ]
def ordered[C, A1, A2, A3, A4, A5, A6](f: (A1, A2, A3, A4, A5, A6) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5, A6))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5], arg10: CellEncoder[A6], arg11: CellDecoder[A6]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int)

scala> val codec = RowCodec.ordered(Ints.apply _)((is: Ints) ⇒ (is.i1, is.i2, is.i3, is.i4, is.i5, is.i6))

scala> codec.encode(Ints(1, 2, 3, 4, 5, 6))
res5: Seq[String] = WrappedArray(1, 2, 3, 4, 5, 6)

scala> codec.decode(Seq("1", "2", "3", "4", "5", "6"))
res6: DecodeResult[Ints] = Success(Ints(1,2,3,4,5,6))
```
f
encoding function.
g
decoding function. ]
def ordered[C, A1, A2, A3, A4, A5](f: (A1, A2, A3, A4, A5) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4, A5))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4], arg8: CellEncoder[A5], arg9: CellDecoder[A5]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int)

scala> val codec = RowCodec.ordered(Ints.apply _)((is: Ints) ⇒ (is.i1, is.i2, is.i3, is.i4, is.i5))

scala> codec.encode(Ints(1, 2, 3, 4, 5))
res4: Seq[String] = WrappedArray(1, 2, 3, 4, 5)

scala> codec.decode(Seq("1", "2", "3", "4", "5"))
res5: DecodeResult[Ints] = Success(Ints(1,2,3,4,5))
```
f
encoding function.
g
decoding function. ]
def ordered[C, A1, A2, A3, A4](f: (A1, A2, A3, A4) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int, i4: Int)

scala> val codec = RowCodec.ordered(Ints.apply _)((is: Ints) ⇒ (is.i1, is.i2, is.i3, is.i4))

scala> codec.encode(Ints(1, 2, 3, 4))
res3: Seq[String] = WrappedArray(1, 2, 3, 4)

scala> codec.decode(Seq("1", "2", "3", "4"))
res4: DecodeResult[Ints] = Success(Ints(1,2,3,4))
```
f
encoding function.
g
decoding function. ]
def ordered[C, A1, A2, A3](f: (A1, A2, A3) ⇒ C)(g: (C) ⇒ (A1, A2, A3))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
For example:
```
scala> case class Ints(i1: Int, i2: Int, i3: Int)

scala> val codec = RowCodec.ordered(Ints.apply _)((is: Ints) ⇒ (is.i1, is.i2, is.i3))

scala> codec.encode(Ints(1, 2, 3))
res2: Seq[String] = WrappedArray(1, 2, 3)

scala> codec.decode(Seq("1", "2", "3"))
res3: DecodeResult[Ints] = Success(Ints(1,2,3))
```
f
encoding function.
g
decoding function. ]
def ordered[C, A1, A2](f: (A1, A2) ⇒ C)(g: (C) ⇒ (A1, A2))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
For example:
```
scala> case class Ints(i1: Int, i2: Int)

scala> val codec = RowCodec.ordered(Ints.apply _)((is: Ints) ⇒ (is.i1, is.i2))

scala> codec.encode(Ints(1, 2))
res1: Seq[String] = WrappedArray(1, 2)

scala> codec.decode(Seq("1", "2"))
res2: DecodeResult[Ints] = Success(Ints(1,2))
```
f
encoding function.
g
decoding function. ]
def ordered[C, A1](f: (A1) ⇒ C)(g: (C) ⇒ A1)(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1]): RowCodec[C]

Creates a new RowCodec instance from the specified encoding and decoding functions.
Creates a new RowCodec instance from the specified encoding and decoding functions.
For example:
```
scala> case class Ints(i1: Int)

scala> val codec = RowCodec.ordered(Ints.apply _)((is: Ints) ⇒ (is.i1))

scala> codec.encode(Ints(1))
res0: Seq[String] = List(1)

scala> codec.decode(Seq("1"))
res1: DecodeResult[Ints] = Success(Ints(1))
```
f
encoding function.
g
decoding function.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Doc: package csv

trait GeneratedRowCodecs extends AnyRef

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def caseCodec[C, A1, A2, A3](i1: Int, i2: Int, i3: Int)(f: (A1, A2, A3) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3]): RowCodec[C]

def caseCodec[C, A1, A2](i1: Int, i2: Int)(f: (A1, A2) ⇒ C)(g: (C) ⇒ Option[(A1, A2)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2]): RowCodec[C]

def caseCodec[C, A1](f: (A1) ⇒ C)(g: (C) ⇒ Option[A1])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1]): RowCodec[C]

def caseOrdered[C, A1, A2, A3](f: (A1, A2, A3) ⇒ C)(g: (C) ⇒ Option[(A1, A2, A3)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3]): RowCodec[C]

def caseOrdered[C, A1, A2](f: (A1, A2) ⇒ C)(g: (C) ⇒ Option[(A1, A2)])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2]): RowCodec[C]

def caseOrdered[C, A1](f: (A1) ⇒ C)(g: (C) ⇒ Option[A1])(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1]): RowCodec[C]

def clone(): AnyRef

def codec[C, A1, A2, A3](i1: Int, i2: Int, i3: Int)(f: (A1, A2, A3) ⇒ C)(g: (C) ⇒ (A1, A2, A3))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3]): RowCodec[C]

def codec[C, A1, A2](i1: Int, i2: Int)(f: (A1, A2) ⇒ C)(g: (C) ⇒ (A1, A2))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2]): RowCodec[C]

def codec[C, A1](f: (A1) ⇒ C)(g: (C) ⇒ A1)(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1]): RowCodec[C]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def ordered[C, A1, A2, A3, A4](f: (A1, A2, A3, A4) ⇒ C)(g: (C) ⇒ (A1, A2, A3, A4))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3], arg6: CellEncoder[A4], arg7: CellDecoder[A4]): RowCodec[C]

def ordered[C, A1, A2, A3](f: (A1, A2, A3) ⇒ C)(g: (C) ⇒ (A1, A2, A3))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2], arg4: CellEncoder[A3], arg5: CellDecoder[A3]): RowCodec[C]

def ordered[C, A1, A2](f: (A1, A2) ⇒ C)(g: (C) ⇒ (A1, A2))(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1], arg2: CellEncoder[A2], arg3: CellDecoder[A2]): RowCodec[C]

def ordered[C, A1](f: (A1) ⇒ C)(g: (C) ⇒ A1)(implicit arg0: CellEncoder[A1], arg1: CellDecoder[A1]): RowCodec[C]

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped