HeaderDecoder

Value Members

final def !=(arg0: Any): Boolean

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

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

Definition Classes
AnyRef → Any
macro def apply[A](implicit ev: HeaderDecoder[A]): HeaderDecoder[A]

Summons an implicit instance of HeaderDecoder if one can be found, fails compilation otherwise.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def decoder[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, R](f1: String, f2: String, f3: String, f4: String, f5: String, f6: String, f7: String, f8: String, f9: String, f10: String, f11: String, f12: String, f13: String, f14: String, f15: String, f16: String, f17: String, f18: String, f19: String, f20: String, f21: String, f22: String)(f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22) ⇒ R)(implicit arg0: CellDecoder[A1], arg1: CellDecoder[A2], arg2: CellDecoder[A3], arg3: CellDecoder[A4], arg4: CellDecoder[A5], arg5: CellDecoder[A6], arg6: CellDecoder[A7], arg7: CellDecoder[A8], arg8: CellDecoder[A9], arg9: CellDecoder[A10], arg10: CellDecoder[A11], arg11: CellDecoder[A12], arg12: CellDecoder[A13], arg13: CellDecoder[A14], arg14: CellDecoder[A15], arg15: CellDecoder[A16], arg16: CellDecoder[A17], arg17: CellDecoder[A18], arg18: CellDecoder[A19], arg19: CellDecoder[A20], arg20: CellDecoder[A21], arg21: CellDecoder[A22]): HeaderDecoder[R]

Creates a new HeaderDecoder from the specified field list and function.
Creates a new HeaderDecoder from the specified field list and function.
For example:
```
scala> import kantan.csv.ops._

scala> case class Foo(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> implicit val decoder: HeaderDecoder[Foo] = HeaderDecoder.decoder("f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18", "f19", "f20", "f21", "f22")(Foo.apply _)

scala> "f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21, f22\n1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22".asCsvReader[Foo](rfc.withHeader).next()
res21: ReadResult[Foo] = Success(Foo(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22))
```
Definition Classes
GeneratedHeaderDecoders
def decoder[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, R](f1: String, f2: String, f3: String, f4: String, f5: String, f6: String, f7: String, f8: String, f9: String, f10: String, f11: String, f12: String, f13: String, f14: String, f15: String, f16: String, f17: String, f18: String, f19: String, f20: String, f21: String)(f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) ⇒ R)(implicit arg0: CellDecoder[A1], arg1: CellDecoder[A2], arg2: CellDecoder[A3], arg3: CellDecoder[A4], arg4: CellDecoder[A5], arg5: CellDecoder[A6], arg6: CellDecoder[A7], arg7: CellDecoder[A8], arg8: CellDecoder[A9], arg9: CellDecoder[A10], arg10: CellDecoder[A11], arg11: CellDecoder[A12], arg12: CellDecoder[A13], arg13: CellDecoder[A14], arg14: CellDecoder[A15], arg15: CellDecoder[A16], arg16: CellDecoder[A17], arg17: CellDecoder[A18], arg18: CellDecoder[A19], arg19: CellDecoder[A20], arg20: CellDecoder[A21]): HeaderDecoder[R]

Creates a new HeaderDecoder from the specified field list and function.
Creates a new HeaderDecoder from the specified field list and function.
For example:
```
scala> import kantan.csv.ops._

scala> case class Foo(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> implicit val decoder: HeaderDecoder[Foo] = HeaderDecoder.decoder("f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18", "f19", "f20", "f21")(Foo.apply _)

scala> "f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20, f21\n1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21".asCsvReader[Foo](rfc.withHeader).next()
res20: ReadResult[Foo] = Success(Foo(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21))
```
Definition Classes
GeneratedHeaderDecoders
def decoder[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, R](f1: String, f2: String, f3: String, f4: String, f5: String, f6: String, f7: String, f8: String, f9: String, f10: String, f11: String, f12: String, f13: String, f14: String, f15: String, f16: String, f17: String, f18: String, f19: String, f20: String)(f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) ⇒ R)(implicit arg0: CellDecoder[A1], arg1: CellDecoder[A2], arg2: CellDecoder[A3], arg3: CellDecoder[A4], arg4: CellDecoder[A5], arg5: CellDecoder[A6], arg6: CellDecoder[A7], arg7: CellDecoder[A8], arg8: CellDecoder[A9], arg9: CellDecoder[A10], arg10: CellDecoder[A11], arg11: CellDecoder[A12], arg12: CellDecoder[A13], arg13: CellDecoder[A14], arg14: CellDecoder[A15], arg15: CellDecoder[A16], arg16: CellDecoder[A17], arg17: CellDecoder[A18], arg18: CellDecoder[A19], arg19: CellDecoder[A20]): HeaderDecoder[R]

Creates a new HeaderDecoder from the specified field list and function.
Creates a new HeaderDecoder from the specified field list and function.
For example:
```
scala> import kantan.csv.ops._

scala> case class Foo(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> implicit val decoder: HeaderDecoder[Foo] = HeaderDecoder.decoder("f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18", "f19", "f20")(Foo.apply _)

scala> "f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19, f20\n1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20".asCsvReader[Foo](rfc.withHeader).next()
res19: ReadResult[Foo] = Success(Foo(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20))
```
Definition Classes
GeneratedHeaderDecoders
def decoder[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, R](f1: String, f2: String, f3: String, f4: String, f5: String, f6: String, f7: String, f8: String, f9: String, f10: String, f11: String, f12: String, f13: String, f14: String, f15: String, f16: String, f17: String, f18: String, f19: String)(f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) ⇒ R)(implicit arg0: CellDecoder[A1], arg1: CellDecoder[A2], arg2: CellDecoder[A3], arg3: CellDecoder[A4], arg4: CellDecoder[A5], arg5: CellDecoder[A6], arg6: CellDecoder[A7], arg7: CellDecoder[A8], arg8: CellDecoder[A9], arg9: CellDecoder[A10], arg10: CellDecoder[A11], arg11: CellDecoder[A12], arg12: CellDecoder[A13], arg13: CellDecoder[A14], arg14: CellDecoder[A15], arg15: CellDecoder[A16], arg16: CellDecoder[A17], arg17: CellDecoder[A18], arg18: CellDecoder[A19]): HeaderDecoder[R]

Creates a new HeaderDecoder from the specified field list and function.
Creates a new HeaderDecoder from the specified field list and function.
For example:
```
scala> import kantan.csv.ops._

scala> case class Foo(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> implicit val decoder: HeaderDecoder[Foo] = HeaderDecoder.decoder("f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18", "f19")(Foo.apply _)

scala> "f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18, f19\n1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19".asCsvReader[Foo](rfc.withHeader).next()
res18: ReadResult[Foo] = Success(Foo(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19))
```
Definition Classes
GeneratedHeaderDecoders
def decoder[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, R](f1: String, f2: String, f3: String, f4: String, f5: String, f6: String, f7: String, f8: String, f9: String, f10: String, f11: String, f12: String, f13: String, f14: String, f15: String, f16: String, f17: String, f18: String)(f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) ⇒ R)(implicit arg0: CellDecoder[A1], arg1: CellDecoder[A2], arg2: CellDecoder[A3], arg3: CellDecoder[A4], arg4: CellDecoder[A5], arg5: CellDecoder[A6], arg6: CellDecoder[A7], arg7: CellDecoder[A8], arg8: CellDecoder[A9], arg9: CellDecoder[A10], arg10: CellDecoder[A11], arg11: CellDecoder[A12], arg12: CellDecoder[A13], arg13: CellDecoder[A14], arg14: CellDecoder[A15], arg15: CellDecoder[A16], arg16: CellDecoder[A17], arg17: CellDecoder[A18]): HeaderDecoder[R]

Creates a new HeaderDecoder from the specified field list and function.
Creates a new HeaderDecoder from the specified field list and function.
For example:
```
scala> import kantan.csv.ops._

scala> case class Foo(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> implicit val decoder: HeaderDecoder[Foo] = HeaderDecoder.decoder("f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", "f16", "f17", "f18")(Foo.apply _)

scala> "f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17, f18\n1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18".asCsvReader[Foo](rfc.withHeader).next()
res17: ReadResult[Foo] = Success(Foo(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18))
```
Definition Classes
GeneratedHeaderDecoders
def decoder[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, R](f1: String, f2: String, f3: String, f4: String, f5: String, f6: String, f7: String, f8: String, f9: String, f10: String, f11: String, f12: String, f13: String, f14: String, f15: String, f16: String, f17: String)(f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) ⇒ R)(implicit arg0: CellDecoder[A1], arg1: CellDecoder[A2], arg2: CellDecoder[A3], arg3: CellDecoder[A4], arg4: CellDecoder[A5], arg5: CellDecoder[A6], arg6: CellDecoder[A7], arg7: CellDecoder[A8], arg8: CellDecoder[A9], arg9: CellDecoder[A10], arg10: CellDecoder[A11], arg11: CellDecoder[A12], arg12: CellDecoder[A13], arg13: CellDecoder[A14], arg14: CellDecoder[A15], arg15: CellDecoder[A16], arg16: CellDecoder[A17]): HeaderDecoder[R]

Creates a new HeaderDecoder from the specified field list and function.
Creates a new HeaderDecoder from the specified field list and function.
For example:
```
scala> import kantan.csv.ops._

scala> case class Foo(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> implicit val decoder: HeaderDecoder[Foo] = HeaderDecoder.decoder("f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", "f16", "f17")(Foo.apply _)

scala> "f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16, f17\n1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17".asCsvReader[Foo](rfc.withHeader).next()
res16: ReadResult[Foo] = Success(Foo(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17))
```
Definition Classes
GeneratedHeaderDecoders
def decoder[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R](f1: String, f2: String, f3: String, f4: String, f5: String, f6: String, f7: String, f8: String, f9: String, f10: String, f11: String, f12: String, f13: String, f14: String, f15: String, f16: String)(f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) ⇒ R)(implicit arg0: CellDecoder[A1], arg1: CellDecoder[A2], arg2: CellDecoder[A3], arg3: CellDecoder[A4], arg4: CellDecoder[A5], arg5: CellDecoder[A6], arg6: CellDecoder[A7], arg7: CellDecoder[A8], arg8: CellDecoder[A9], arg9: CellDecoder[A10], arg10: CellDecoder[A11], arg11: CellDecoder[A12], arg12: CellDecoder[A13], arg13: CellDecoder[A14], arg14: CellDecoder[A15], arg15: CellDecoder[A16]): HeaderDecoder[R]

Creates a new HeaderDecoder from the specified field list and function.
Creates a new HeaderDecoder from the specified field list and function.
For example:
```
scala> import kantan.csv.ops._

scala> case class Foo(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> implicit val decoder: HeaderDecoder[Foo] = HeaderDecoder.decoder("f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", "f16")(Foo.apply _)

scala> "f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15, f16\n1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16".asCsvReader[Foo](rfc.withHeader).next()
res15: ReadResult[Foo] = Success(Foo(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16))
```
Definition Classes
GeneratedHeaderDecoders
def decoder[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R](f1: String, f2: String, f3: String, f4: String, f5: String, f6: String, f7: String, f8: String, f9: String, f10: String, f11: String, f12: String, f13: String, f14: String, f15: String)(f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) ⇒ R)(implicit arg0: CellDecoder[A1], arg1: CellDecoder[A2], arg2: CellDecoder[A3], arg3: CellDecoder[A4], arg4: CellDecoder[A5], arg5: CellDecoder[A6], arg6: CellDecoder[A7], arg7: CellDecoder[A8], arg8: CellDecoder[A9], arg9: CellDecoder[A10], arg10: CellDecoder[A11], arg11: CellDecoder[A12], arg12: CellDecoder[A13], arg13: CellDecoder[A14], arg14: CellDecoder[A15]): HeaderDecoder[R]

Creates a new HeaderDecoder from the specified field list and function.
Creates a new HeaderDecoder from the specified field list and function.
For example:
```
scala> import kantan.csv.ops._

scala> case class Foo(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> implicit val decoder: HeaderDecoder[Foo] = HeaderDecoder.decoder("f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15")(Foo.apply _)

scala> "f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15\n1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15".asCsvReader[Foo](rfc.withHeader).next()
res14: ReadResult[Foo] = Success(Foo(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15))
```
Definition Classes
GeneratedHeaderDecoders
def decoder[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R](f1: String, f2: String, f3: String, f4: String, f5: String, f6: String, f7: String, f8: String, f9: String, f10: String, f11: String, f12: String, f13: String, f14: String)(f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) ⇒ R)(implicit arg0: CellDecoder[A1], arg1: CellDecoder[A2], arg2: CellDecoder[A3], arg3: CellDecoder[A4], arg4: CellDecoder[A5], arg5: CellDecoder[A6], arg6: CellDecoder[A7], arg7: CellDecoder[A8], arg8: CellDecoder[A9], arg9: CellDecoder[A10], arg10: CellDecoder[A11], arg11: CellDecoder[A12], arg12: CellDecoder[A13], arg13: CellDecoder[A14]): HeaderDecoder[R]

Creates a new HeaderDecoder from the specified field list and function.
Creates a new HeaderDecoder from the specified field list and function.
For example:
```
scala> import kantan.csv.ops._

scala> case class Foo(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> implicit val decoder: HeaderDecoder[Foo] = HeaderDecoder.decoder("f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", "f11", "f12", "f13", "f14")(Foo.apply _)

scala> "f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14\n1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14".asCsvReader[Foo](rfc.withHeader).next()
res13: ReadResult[Foo] = Success(Foo(1,2,3,4,5,6,7,8,9,10,11,12,13,14))
```
Definition Classes
GeneratedHeaderDecoders
def decoder[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R](f1: String, f2: String, f3: String, f4: String, f5: String, f6: String, f7: String, f8: String, f9: String, f10: String, f11: String, f12: String, f13: String)(f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) ⇒ R)(implicit arg0: CellDecoder[A1], arg1: CellDecoder[A2], arg2: CellDecoder[A3], arg3: CellDecoder[A4], arg4: CellDecoder[A5], arg5: CellDecoder[A6], arg6: CellDecoder[A7], arg7: CellDecoder[A8], arg8: CellDecoder[A9], arg9: CellDecoder[A10], arg10: CellDecoder[A11], arg11: CellDecoder[A12], arg12: CellDecoder[A13]): HeaderDecoder[R]

Creates a new HeaderDecoder from the specified field list and function.
Creates a new HeaderDecoder from the specified field list and function.
For example:
```
scala> import kantan.csv.ops._

scala> case class Foo(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> implicit val decoder: HeaderDecoder[Foo] = HeaderDecoder.decoder("f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", "f11", "f12", "f13")(Foo.apply _)

scala> "f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13\n1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13".asCsvReader[Foo](rfc.withHeader).next()
res12: ReadResult[Foo] = Success(Foo(1,2,3,4,5,6,7,8,9,10,11,12,13))
```
Definition Classes
GeneratedHeaderDecoders
def decoder[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R](f1: String, f2: String, f3: String, f4: String, f5: String, f6: String, f7: String, f8: String, f9: String, f10: String, f11: String, f12: String)(f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) ⇒ R)(implicit arg0: CellDecoder[A1], arg1: CellDecoder[A2], arg2: CellDecoder[A3], arg3: CellDecoder[A4], arg4: CellDecoder[A5], arg5: CellDecoder[A6], arg6: CellDecoder[A7], arg7: CellDecoder[A8], arg8: CellDecoder[A9], arg9: CellDecoder[A10], arg10: CellDecoder[A11], arg11: CellDecoder[A12]): HeaderDecoder[R]

Creates a new HeaderDecoder from the specified field list and function.
Creates a new HeaderDecoder from the specified field list and function.
For example:
```
scala> import kantan.csv.ops._

scala> case class Foo(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> implicit val decoder: HeaderDecoder[Foo] = HeaderDecoder.decoder("f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", "f11", "f12")(Foo.apply _)

scala> "f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12\n1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12".asCsvReader[Foo](rfc.withHeader).next()
res11: ReadResult[Foo] = Success(Foo(1,2,3,4,5,6,7,8,9,10,11,12))
```
Definition Classes
GeneratedHeaderDecoders
def decoder[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R](f1: String, f2: String, f3: String, f4: String, f5: String, f6: String, f7: String, f8: String, f9: String, f10: String, f11: String)(f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) ⇒ R)(implicit arg0: CellDecoder[A1], arg1: CellDecoder[A2], arg2: CellDecoder[A3], arg3: CellDecoder[A4], arg4: CellDecoder[A5], arg5: CellDecoder[A6], arg6: CellDecoder[A7], arg7: CellDecoder[A8], arg8: CellDecoder[A9], arg9: CellDecoder[A10], arg10: CellDecoder[A11]): HeaderDecoder[R]

Creates a new HeaderDecoder from the specified field list and function.
Creates a new HeaderDecoder from the specified field list and function.
For example:
```
scala> import kantan.csv.ops._

scala> case class Foo(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int, i11: Int)
scala> implicit val decoder: HeaderDecoder[Foo] = HeaderDecoder.decoder("f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10", "f11")(Foo.apply _)

scala> "f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11\n1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11".asCsvReader[Foo](rfc.withHeader).next()
res10: ReadResult[Foo] = Success(Foo(1,2,3,4,5,6,7,8,9,10,11))
```
Definition Classes
GeneratedHeaderDecoders
def decoder[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R](f1: String, f2: String, f3: String, f4: String, f5: String, f6: String, f7: String, f8: String, f9: String, f10: String)(f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) ⇒ R)(implicit arg0: CellDecoder[A1], arg1: CellDecoder[A2], arg2: CellDecoder[A3], arg3: CellDecoder[A4], arg4: CellDecoder[A5], arg5: CellDecoder[A6], arg6: CellDecoder[A7], arg7: CellDecoder[A8], arg8: CellDecoder[A9], arg9: CellDecoder[A10]): HeaderDecoder[R]

Creates a new HeaderDecoder from the specified field list and function.
Creates a new HeaderDecoder from the specified field list and function.
For example:
```
scala> import kantan.csv.ops._

scala> case class Foo(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int, i10: Int)
scala> implicit val decoder: HeaderDecoder[Foo] = HeaderDecoder.decoder("f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9", "f10")(Foo.apply _)

scala> "f1, f2, f3, f4, f5, f6, f7, f8, f9, f10\n1, 2, 3, 4, 5, 6, 7, 8, 9, 10".asCsvReader[Foo](rfc.withHeader).next()
res9: ReadResult[Foo] = Success(Foo(1,2,3,4,5,6,7,8,9,10))
```
Definition Classes
GeneratedHeaderDecoders
def decoder[A1, A2, A3, A4, A5, A6, A7, A8, A9, R](f1: String, f2: String, f3: String, f4: String, f5: String, f6: String, f7: String, f8: String, f9: String)(f: (A1, A2, A3, A4, A5, A6, A7, A8, A9) ⇒ R)(implicit arg0: CellDecoder[A1], arg1: CellDecoder[A2], arg2: CellDecoder[A3], arg3: CellDecoder[A4], arg4: CellDecoder[A5], arg5: CellDecoder[A6], arg6: CellDecoder[A7], arg7: CellDecoder[A8], arg8: CellDecoder[A9]): HeaderDecoder[R]

Creates a new HeaderDecoder from the specified field list and function.
Creates a new HeaderDecoder from the specified field list and function.
For example:
```
scala> import kantan.csv.ops._

scala> case class Foo(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int, i9: Int)
scala> implicit val decoder: HeaderDecoder[Foo] = HeaderDecoder.decoder("f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8", "f9")(Foo.apply _)

scala> "f1, f2, f3, f4, f5, f6, f7, f8, f9\n1, 2, 3, 4, 5, 6, 7, 8, 9".asCsvReader[Foo](rfc.withHeader).next()
res8: ReadResult[Foo] = Success(Foo(1,2,3,4,5,6,7,8,9))
```
Definition Classes
GeneratedHeaderDecoders
def decoder[A1, A2, A3, A4, A5, A6, A7, A8, R](f1: String, f2: String, f3: String, f4: String, f5: String, f6: String, f7: String, f8: String)(f: (A1, A2, A3, A4, A5, A6, A7, A8) ⇒ R)(implicit arg0: CellDecoder[A1], arg1: CellDecoder[A2], arg2: CellDecoder[A3], arg3: CellDecoder[A4], arg4: CellDecoder[A5], arg5: CellDecoder[A6], arg6: CellDecoder[A7], arg7: CellDecoder[A8]): HeaderDecoder[R]

Creates a new HeaderDecoder from the specified field list and function.
Creates a new HeaderDecoder from the specified field list and function.
For example:
```
scala> import kantan.csv.ops._

scala> case class Foo(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int, i8: Int)
scala> implicit val decoder: HeaderDecoder[Foo] = HeaderDecoder.decoder("f1", "f2", "f3", "f4", "f5", "f6", "f7", "f8")(Foo.apply _)

scala> "f1, f2, f3, f4, f5, f6, f7, f8\n1, 2, 3, 4, 5, 6, 7, 8".asCsvReader[Foo](rfc.withHeader).next()
res7: ReadResult[Foo] = Success(Foo(1,2,3,4,5,6,7,8))
```
Definition Classes
GeneratedHeaderDecoders
def decoder[A1, A2, A3, A4, A5, A6, A7, R](f1: String, f2: String, f3: String, f4: String, f5: String, f6: String, f7: String)(f: (A1, A2, A3, A4, A5, A6, A7) ⇒ R)(implicit arg0: CellDecoder[A1], arg1: CellDecoder[A2], arg2: CellDecoder[A3], arg3: CellDecoder[A4], arg4: CellDecoder[A5], arg5: CellDecoder[A6], arg6: CellDecoder[A7]): HeaderDecoder[R]

Creates a new HeaderDecoder from the specified field list and function.
Creates a new HeaderDecoder from the specified field list and function.
For example:
```
scala> import kantan.csv.ops._

scala> case class Foo(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int, i7: Int)
scala> implicit val decoder: HeaderDecoder[Foo] = HeaderDecoder.decoder("f1", "f2", "f3", "f4", "f5", "f6", "f7")(Foo.apply _)

scala> "f1, f2, f3, f4, f5, f6, f7\n1, 2, 3, 4, 5, 6, 7".asCsvReader[Foo](rfc.withHeader).next()
res6: ReadResult[Foo] = Success(Foo(1,2,3,4,5,6,7))
```
Definition Classes
GeneratedHeaderDecoders
def decoder[A1, A2, A3, A4, A5, A6, R](f1: String, f2: String, f3: String, f4: String, f5: String, f6: String)(f: (A1, A2, A3, A4, A5, A6) ⇒ R)(implicit arg0: CellDecoder[A1], arg1: CellDecoder[A2], arg2: CellDecoder[A3], arg3: CellDecoder[A4], arg4: CellDecoder[A5], arg5: CellDecoder[A6]): HeaderDecoder[R]

Creates a new HeaderDecoder from the specified field list and function.
Creates a new HeaderDecoder from the specified field list and function.
For example:
```
scala> import kantan.csv.ops._

scala> case class Foo(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int, i6: Int)
scala> implicit val decoder: HeaderDecoder[Foo] = HeaderDecoder.decoder("f1", "f2", "f3", "f4", "f5", "f6")(Foo.apply _)

scala> "f1, f2, f3, f4, f5, f6\n1, 2, 3, 4, 5, 6".asCsvReader[Foo](rfc.withHeader).next()
res5: ReadResult[Foo] = Success(Foo(1,2,3,4,5,6))
```
Definition Classes
GeneratedHeaderDecoders
def decoder[A1, A2, A3, A4, A5, R](f1: String, f2: String, f3: String, f4: String, f5: String)(f: (A1, A2, A3, A4, A5) ⇒ R)(implicit arg0: CellDecoder[A1], arg1: CellDecoder[A2], arg2: CellDecoder[A3], arg3: CellDecoder[A4], arg4: CellDecoder[A5]): HeaderDecoder[R]

Creates a new HeaderDecoder from the specified field list and function.
Creates a new HeaderDecoder from the specified field list and function.
For example:
```
scala> import kantan.csv.ops._

scala> case class Foo(i1: Int, i2: Int, i3: Int, i4: Int, i5: Int)
scala> implicit val decoder: HeaderDecoder[Foo] = HeaderDecoder.decoder("f1", "f2", "f3", "f4", "f5")(Foo.apply _)

scala> "f1, f2, f3, f4, f5\n1, 2, 3, 4, 5".asCsvReader[Foo](rfc.withHeader).next()
res4: ReadResult[Foo] = Success(Foo(1,2,3,4,5))
```
Definition Classes
GeneratedHeaderDecoders
def decoder[A1, A2, A3, A4, R](f1: String, f2: String, f3: String, f4: String)(f: (A1, A2, A3, A4) ⇒ R)(implicit arg0: CellDecoder[A1], arg1: CellDecoder[A2], arg2: CellDecoder[A3], arg3: CellDecoder[A4]): HeaderDecoder[R]

Creates a new HeaderDecoder from the specified field list and function.
Creates a new HeaderDecoder from the specified field list and function.
For example:
```
scala> import kantan.csv.ops._

scala> case class Foo(i1: Int, i2: Int, i3: Int, i4: Int)
scala> implicit val decoder: HeaderDecoder[Foo] = HeaderDecoder.decoder("f1", "f2", "f3", "f4")(Foo.apply _)

scala> "f1, f2, f3, f4\n1, 2, 3, 4".asCsvReader[Foo](rfc.withHeader).next()
res3: ReadResult[Foo] = Success(Foo(1,2,3,4))
```
Definition Classes
GeneratedHeaderDecoders
def decoder[A1, A2, A3, R](f1: String, f2: String, f3: String)(f: (A1, A2, A3) ⇒ R)(implicit arg0: CellDecoder[A1], arg1: CellDecoder[A2], arg2: CellDecoder[A3]): HeaderDecoder[R]

Creates a new HeaderDecoder from the specified field list and function.
Creates a new HeaderDecoder from the specified field list and function.
For example:
```
scala> import kantan.csv.ops._

scala> case class Foo(i1: Int, i2: Int, i3: Int)
scala> implicit val decoder: HeaderDecoder[Foo] = HeaderDecoder.decoder("f1", "f2", "f3")(Foo.apply _)

scala> "f1, f2, f3\n1, 2, 3".asCsvReader[Foo](rfc.withHeader).next()
res2: ReadResult[Foo] = Success(Foo(1,2,3))
```
Definition Classes
GeneratedHeaderDecoders
def decoder[A1, A2, R](f1: String, f2: String)(f: (A1, A2) ⇒ R)(implicit arg0: CellDecoder[A1], arg1: CellDecoder[A2]): HeaderDecoder[R]

Creates a new HeaderDecoder from the specified field list and function.
Creates a new HeaderDecoder from the specified field list and function.
For example:
```
scala> import kantan.csv.ops._

scala> case class Foo(i1: Int, i2: Int)
scala> implicit val decoder: HeaderDecoder[Foo] = HeaderDecoder.decoder("f1", "f2")(Foo.apply _)

scala> "f1, f2\n1, 2".asCsvReader[Foo](rfc.withHeader).next()
res1: ReadResult[Foo] = Success(Foo(1,2))
```
Definition Classes
GeneratedHeaderDecoders
def decoder[A1, R](f1: String)(f: (A1) ⇒ R)(implicit arg0: CellDecoder[A1]): HeaderDecoder[R]

Creates a new HeaderDecoder from the specified field list and function.
Creates a new HeaderDecoder from the specified field list and function.
For example:
```
scala> import kantan.csv.ops._

scala> case class Foo(i1: Int)
scala> implicit val decoder: HeaderDecoder[Foo] = HeaderDecoder.decoder("f1")(Foo.apply _)

scala> "f1\n1".asCsvReader[Foo](rfc.withHeader).next()
res0: ReadResult[Foo] = Success(Foo(1))
```
Definition Classes
GeneratedHeaderDecoders
implicit def defaultHeaderDecoder[A](implicit arg0: RowDecoder[A]): HeaderDecoder[A]

When no HeaderDecoder is available, fallback on whatever instance of RowDecoder is in scope.
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
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 Docs: trait HeaderDecoder | package csv

object HeaderDecoder extends GeneratedHeaderDecoders with Serializable

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

macro def apply[A](implicit ev: HeaderDecoder[A]): HeaderDecoder[A]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def decoder[A1, A2, A3, A4, A5, R](f1: String, f2: String, f3: String, f4: String, f5: String)(f: (A1, A2, A3, A4, A5) ⇒ R)(implicit arg0: CellDecoder[A1], arg1: CellDecoder[A2], arg2: CellDecoder[A3], arg3: CellDecoder[A4], arg4: CellDecoder[A5]): HeaderDecoder[R]

def decoder[A1, A2, A3, A4, R](f1: String, f2: String, f3: String, f4: String)(f: (A1, A2, A3, A4) ⇒ R)(implicit arg0: CellDecoder[A1], arg1: CellDecoder[A2], arg2: CellDecoder[A3], arg3: CellDecoder[A4]): HeaderDecoder[R]

def decoder[A1, A2, A3, R](f1: String, f2: String, f3: String)(f: (A1, A2, A3) ⇒ R)(implicit arg0: CellDecoder[A1], arg1: CellDecoder[A2], arg2: CellDecoder[A3]): HeaderDecoder[R]

def decoder[A1, A2, R](f1: String, f2: String)(f: (A1, A2) ⇒ R)(implicit arg0: CellDecoder[A1], arg1: CellDecoder[A2]): HeaderDecoder[R]

def decoder[A1, R](f1: String)(f: (A1) ⇒ R)(implicit arg0: CellDecoder[A1]): HeaderDecoder[R]

implicit def defaultHeaderDecoder[A](implicit arg0: RowDecoder[A]): HeaderDecoder[A]

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

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 Serializable

Inherited from Serializable

Inherited from GeneratedHeaderDecoders

Inherited from AnyRef

Inherited from Any

Ungrouped