final class Tuple9Codec[A, B, C, D, E, F, G, H, I] extends Codec[(A, B, C, D, E, F, G, H, I)]
- Grouped
- Alphabetic
- By Inheritance
- Tuple9Codec
- Codec
- GenCodec
- Decoder
- Encoder
- AnyRef
- Any
- by Tuple2CodecSupport
- by EnrichedCoproductEncoder
- by ValueCodecEnrichedWithGenericSupport
- by ValueCodecEnrichedWithHListSupport
- by TransformSyntax
- by ValueEnrichedWithTuplingSupport
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
- Public
- All
Instance Constructors
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
def
+(other: String): String
- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to any2stringadd[Tuple9Codec[A, B, C, D, E, F, G, H, I]] performed by method any2stringadd in scala.Predef.
- Definition Classes
- any2stringadd
-
def
->[B](y: B): (Tuple9Codec[A, B, C, D, E, F, G, H, I], B)
- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to ArrowAssoc[Tuple9Codec[A, B, C, D, E, F, G, H, I]] performed by method ArrowAssoc in scala.Predef.
- Definition Classes
- ArrowAssoc
- Annotations
- @inline()
-
def
:+:[B](left: Codec[B]): CoproductCodecBuilder[:+:[B, :+:[(A, B, C, D, E, F, G, H, I), CNil]], ::[Codec[B], ::[Codec[(A, B, C, D, E, F, G, H, I)], HNil]], :+:[B, :+:[(A, B, C, D, E, F, G, H, I), CNil]]]
Supports creation of a coproduct codec.
Supports creation of a coproduct codec. See scodec.codecs.CoproductCodecBuilder for details.
- Definition Classes
- Codec
-
def
::[B](codecB: Codec[B]): Codec[::[B, ::[(A, B, C, D, E, F, G, H, I), HNil]]]
When called on a
Codec[A]
whereA
is not a subytpe ofHList
, creates a new codec that encodes/decodes anHList
ofB :: A :: HNil
.When called on a
Codec[A]
whereA
is not a subytpe ofHList
, creates a new codec that encodes/decodes anHList
ofB :: A :: HNil
. For example,uint8 :: utf8
has type
Codec[Int :: String :: HNil]
. uint8 :: utf8 }}}- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to ValueCodecEnrichedWithHListSupport[(A, B, C, D, E, F, G, H, I)] performed by method ValueCodecEnrichedWithHListSupport in scodec.
- Definition Classes
- ValueCodecEnrichedWithHListSupport
-
def
:~>:[B](codecB: Codec[B])(implicit ev: =:=[Unit, B]): Codec[::[(A, B, C, D, E, F, G, H, I), HNil]]
When called on a
Codec[A]
, returns a new codec that encodes/decodesB :: A :: HNil
.When called on a
Codec[A]
, returns a new codec that encodes/decodesB :: A :: HNil
. HList equivalent of~>
.- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to ValueCodecEnrichedWithHListSupport[(A, B, C, D, E, F, G, H, I)] performed by method ValueCodecEnrichedWithHListSupport in scodec.
- Definition Classes
- ValueCodecEnrichedWithHListSupport
-
final
def
<~[B](codecB: Codec[B])(implicit ev: =:=[Unit, B]): Codec[(A, B, C, D, E, F, G, H, I)]
Assuming
B
isUnit
, creates aCodec[A]
that: encodes theA
followed by a unit; decodes anA
followed by a unit and discards the decoded unit. -
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
>>:~[L <: HList](f: ((A, B, C, D, E, F, G, H, I)) ⇒ Codec[L]): Codec[::[(A, B, C, D, E, F, G, H, I), L]]
Creates a new codec that encodes/decodes an
HList
type ofA :: L
given a functionA => Codec[L]
.Creates a new codec that encodes/decodes an
HList
type ofA :: L
given a functionA => Codec[L]
. This allows later parts of anHList
codec to be dependent on earlier values. Operator alias forflatPrepend
.- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to ValueCodecEnrichedWithHListSupport[(A, B, C, D, E, F, G, H, I)] performed by method ValueCodecEnrichedWithHListSupport in scodec.
- Definition Classes
- ValueCodecEnrichedWithHListSupport
-
final
def
>>~[B](f: ((A, B, C, D, E, F, G, H, I)) ⇒ Codec[B]): Codec[((A, B, C, D, E, F, G, H, I), B)]
Returns a new codec that encodes/decodes a value of type
(A, B)
where the codec ofB
is dependent onA
. -
val
a: Tuple9Codec[A, B, C, D, E, F, G, H, I]
- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to ValueEnrichedWithTuplingSupport[Tuple9Codec[A, B, C, D, E, F, G, H, I]] performed by method ValueEnrichedWithTuplingSupport in scodec.codecs.
- Definition Classes
- ValueEnrichedWithTuplingSupport
-
def
as[B](implicit as: Transformer[(A, B, C, D, E, F, G, H, I), B]): Codec[B]
Transforms using implicitly available evidence that such a transformation is possible.
Transforms using implicitly available evidence that such a transformation is possible.
Typical transformations include converting:
- an
F[L]
for someL <: HList
to/from anF[CC]
for some case classCC
, where the types in the case class are aligned with the types inL
- an
F[C]
for someC <: Coproduct
to/from anF[SC]
for some sealed classSC
, where the component types in the coproduct are the leaf subtypes of the sealed class.
- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to TransformSyntax[Codec, (A, B, C, D, E, F, G, H, I)] performed by method TransformSyntax in scodec.
- Definition Classes
- TransformSyntax
- an
-
def
asDecoder: Decoder[(A, B, C, D, E, F, G, H, I)]
Gets this as a
Decoder
.Gets this as a
Decoder
.- Definition Classes
- Decoder
-
def
asEncoder: Encoder[(A, B, C, D, E, F, G, H, I)]
Gets this as an
Encoder
.Gets this as an
Encoder
.- Definition Classes
- Encoder
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
compact: Codec[(A, B, C, D, E, F, G, H, I)]
Converts this codec to a new codec that compacts the encoded bit vector before returning it.
-
final
def
complete: Codec[(A, B, C, D, E, F, G, H, I)]
Converts this codec to a new codec that fails decoding if there are remaining bits.
-
final
def
consume[B](f: ((A, B, C, D, E, F, G, H, I)) ⇒ Codec[B])(g: (B) ⇒ (A, B, C, D, E, F, G, H, I)): Codec[B]
Similar to
flatZip
except theA
type is not visible in the resulting type -- the binary effects of theCodec[A]
still occur though.Similar to
flatZip
except theA
type is not visible in the resulting type -- the binary effects of theCodec[A]
still occur though.Example usage:
case class Flags(x: Boolean, y: Boolean, z: Boolean) (bool :: bool :: bool :: ignore(5)).consume { flgs => conditional(flgs.x, uint8) :: conditional(flgs.y, uint8) :: conditional(flgs.z, uint8) } { case x :: y :: z :: HNil => Flags(x.isDefined, y.isDefined, z.isDefined) } }
Note that when
B
is anHList
, this method is equivalent to usingflatPrepend
andderive
. That is,a.consume(f)(g) === a.flatPrepend(f).derive[A].from(g)
.- Definition Classes
- Codec
-
def
contramap[C](f: (C) ⇒ (A, B, C, D, E, F, G, H, I)): GenCodec[C, (A, B, C, D, E, F, G, H, I)]
Converts this
GenCodec
to aGenCodec[C, B]
using the suppliedC => A
. -
def
decode(bits: BitVector): Attempt[DecodeResult[(A, B, C, D, E, F, G, H, I)]]
Attempts to decode a value of type
A
from the specified bit vector.Attempts to decode a value of type
A
from the specified bit vector.- bits
bits to decode
- returns
error if value could not be decoded or the remaining bits and the decoded value
- Definition Classes
- Tuple9Codec → Decoder
-
def
decodeOnly[AA >: (A, B, C, D, E, F, G, H, I)]: Codec[AA]
Converts this to a codec that fails encoding with an error.
-
final
def
decodeValue(bits: BitVector): Attempt[(A, B, C, D, E, F, G, H, I)]
Attempts to decode a value of type
A
from the specified bit vector and discards the remaining bits.Attempts to decode a value of type
A
from the specified bit vector and discards the remaining bits.- bits
bits to decode
- returns
error if value could not be decoded or the decoded value
- Definition Classes
- Decoder
-
final
def
downcast[B <: (A, B, C, D, E, F, G, H, I)](implicit tb: Typeable[B]): Codec[B]
Safely lifts this codec to a codec of a subtype.
Safely lifts this codec to a codec of a subtype.
When a supertype of
B
that is not a supertype ofA
is decoded, an decoding error is returned.- Definition Classes
- Codec
-
final
def
dropLeft[B](codecB: Codec[B])(implicit ev: =:=[Unit, (A, B, C, D, E, F, G, H, I)]): Codec[B]
Assuming
A
isUnit
, creates aCodec[B]
that: encodes the unit followed by aB
; decodes a unit followed by aB
and discards the decoded unit.Assuming
A
isUnit
, creates aCodec[B]
that: encodes the unit followed by aB
; decodes a unit followed by aB
and discards the decoded unit.- Definition Classes
- Codec
-
final
def
dropRight[B](codecB: Codec[B])(implicit ev: =:=[Unit, B]): Codec[(A, B, C, D, E, F, G, H, I)]
Assuming
B
isUnit
, creates aCodec[A]
that: encodes theA
followed by a unit; decodes anA
followed by a unit and discards the decoded unit.Assuming
B
isUnit
, creates aCodec[A]
that: encodes theA
followed by a unit; decodes anA
followed by a unit and discards the decoded unit.- Definition Classes
- Codec
-
def
econtramap[C](f: (C) ⇒ Attempt[(A, B, C, D, E, F, G, H, I)]): GenCodec[C, (A, B, C, D, E, F, G, H, I)]
Converts this
GenCodec
to aGenCodec[C, B]
using the suppliedC => Attempt[A]
. -
def
emap[C](f: ((A, B, C, D, E, F, G, H, I)) ⇒ Attempt[C]): GenCodec[(A, B, C, D, E, F, G, H, I), C]
Converts this
GenCodec
to aGenCodec[A, C]
using the suppliedB => Attempt[C]
. -
def
encode(abcdefghi: (A, B, C, D, E, F, G, H, I)): Attempt[BitVector]
Attempts to encode the specified value in to a bit vector.
Attempts to encode the specified value in to a bit vector.
- returns
error or binary encoding of the value
- Definition Classes
- Tuple9Codec → Encoder
-
def
encodeOnly: Codec[(A, B, C, D, E, F, G, H, I)]
Converts this to a codec that fails decoding with an error.
Converts this to a codec that fails decoding with an error.
- Definition Classes
- Encoder
-
def
ensuring(cond: (Tuple9Codec[A, B, C, D, E, F, G, H, I]) ⇒ Boolean, msg: ⇒ Any): Tuple9Codec[A, B, C, D, E, F, G, H, I]
- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to Ensuring[Tuple9Codec[A, B, C, D, E, F, G, H, I]] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
-
def
ensuring(cond: (Tuple9Codec[A, B, C, D, E, F, G, H, I]) ⇒ Boolean): Tuple9Codec[A, B, C, D, E, F, G, H, I]
- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to Ensuring[Tuple9Codec[A, B, C, D, E, F, G, H, I]] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
-
def
ensuring(cond: Boolean, msg: ⇒ Any): Tuple9Codec[A, B, C, D, E, F, G, H, I]
- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to Ensuring[Tuple9Codec[A, B, C, D, E, F, G, H, I]] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
-
def
ensuring(cond: Boolean): Tuple9Codec[A, B, C, D, E, F, G, H, I]
- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to Ensuring[Tuple9Codec[A, B, C, D, E, F, G, H, I]] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
exmap[B](f: ((A, B, C, D, E, F, G, H, I)) ⇒ Attempt[B], g: (B) ⇒ Attempt[(A, B, C, D, E, F, G, H, I)]): Codec[B]
Transforms using two functions,
A => Attempt[B]
andB => Attempt[A]
.Transforms using two functions,
A => Attempt[B]
andB => Attempt[A]
.- Definition Classes
- Codec
-
def
exmapc[B](f: ((A, B, C, D, E, F, G, H, I)) ⇒ Attempt[B])(g: (B) ⇒ Attempt[(A, B, C, D, E, F, G, H, I)]): Codec[B]
Curried version of
exmap
.Curried version of
exmap
.- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to TransformSyntax[Codec, (A, B, C, D, E, F, G, H, I)] performed by method TransformSyntax in scodec.
- Definition Classes
- TransformSyntax
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
flatMap[B](f: ((A, B, C, D, E, F, G, H, I)) ⇒ Decoder[B]): Decoder[B]
Converts this decoder to a
Decoder[B]
using the suppliedA => Decoder[B]
.Converts this decoder to a
Decoder[B]
using the suppliedA => Decoder[B]
.- Definition Classes
- Decoder
-
def
flatPrepend[L <: HList](f: ((A, B, C, D, E, F, G, H, I)) ⇒ Codec[L]): Codec[::[(A, B, C, D, E, F, G, H, I), L]]
Creates a new codec that encodes/decodes an
HList
type ofA :: L
given a functionA => Codec[L]
.Creates a new codec that encodes/decodes an
HList
type ofA :: L
given a functionA => Codec[L]
. This allows later parts of anHList
codec to be dependent on earlier values.- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to ValueCodecEnrichedWithHListSupport[(A, B, C, D, E, F, G, H, I)] performed by method ValueCodecEnrichedWithHListSupport in scodec.
- Definition Classes
- ValueCodecEnrichedWithHListSupport
-
final
def
flatZip[B](f: ((A, B, C, D, E, F, G, H, I)) ⇒ Codec[B]): Codec[((A, B, C, D, E, F, G, H, I), B)]
Returns a new codec that encodes/decodes a value of type
(A, B)
where the codec ofB
is dependent onA
.Returns a new codec that encodes/decodes a value of type
(A, B)
where the codec ofB
is dependent onA
.- Definition Classes
- Codec
-
def
flatZipHList[B](f: ((A, B, C, D, E, F, G, H, I)) ⇒ Codec[B]): Codec[::[(A, B, C, D, E, F, G, H, I), ::[B, HNil]]]
Creates a new codec that encodes/decodes an
HList
type ofA :: B :: HNil
given a functionA => Codec[B]
.Creates a new codec that encodes/decodes an
HList
type ofA :: B :: HNil
given a functionA => Codec[B]
. IfB
is anHList
type, consider usingflatPrepend
instead, which avoids nestedHLists
. This is the directHList
equivalent offlatZip
.- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to ValueCodecEnrichedWithHListSupport[(A, B, C, D, E, F, G, H, I)] performed by method ValueCodecEnrichedWithHListSupport in scodec.
- Definition Classes
- ValueCodecEnrichedWithHListSupport
-
final
def
flattenLeftPairs(implicit f: FlattenLeftPairs[(A, B, C, D, E, F, G, H, I)]): Codec[Out]
Converts this codec to an
HList
based codec by flattening all left nested pairs.Converts this codec to an
HList
based codec by flattening all left nested pairs. For example,flattenLeftPairs
on aCodec[(((A, B), C), D)]
results in aCodec[A :: B :: C :: D :: HNil]
. This is particularly useful when combined with~
,~>
, and<~
.- Definition Classes
- Codec
-
def
formatted(fmtstr: String): String
- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to StringFormat[Tuple9Codec[A, B, C, D, E, F, G, H, I]] performed by method StringFormat in scala.Predef.
- Definition Classes
- StringFormat
- Annotations
- @inline()
-
final
def
fuse[AA <: (A, B, C, D, E, F, G, H, I), BB >: (A, B, C, D, E, F, G, H, I)](implicit ev: =:=[BB, AA]): Codec[BB]
Converts this generalized codec in to a non-generalized codec assuming
A
andB
are the same type.Converts this generalized codec in to a non-generalized codec assuming
A
andB
are the same type.- Definition Classes
- GenCodec
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
-
final
def
hlist: Codec[::[(A, B, C, D, E, F, G, H, I), HNil]]
Lifts this codec in to a codec of a singleton hlist.
Lifts this codec in to a codec of a singleton hlist.
- Definition Classes
- Codec
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
map[C](f: ((A, B, C, D, E, F, G, H, I)) ⇒ C): GenCodec[(A, B, C, D, E, F, G, H, I), C]
Converts this
GenCodec
to aGenCodec[A, C]
using the suppliedB => C
. -
final
def
narrow[B](f: ((A, B, C, D, E, F, G, H, I)) ⇒ Attempt[B], g: (B) ⇒ (A, B, C, D, E, F, G, H, I)): Codec[B]
Transforms using two functions,
A => Attempt[B]
andB => A
.Transforms using two functions,
A => Attempt[B]
andB => A
.The supplied functions form an injection from
B
toA
. Hence, this method converts from a larger to a smaller type. Hence, the namenarrow
.- Definition Classes
- Codec
-
def
narrowc[B](f: ((A, B, C, D, E, F, G, H, I)) ⇒ Attempt[B])(g: (B) ⇒ (A, B, C, D, E, F, G, H, I)): Codec[B]
Curried version of
narrow
.Curried version of
narrow
.- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to TransformSyntax[Codec, (A, B, C, D, E, F, G, H, I)] performed by method TransformSyntax in scodec.
- Definition Classes
- TransformSyntax
-
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
pairedWith[B](codecB: Codec[B]): Codec[((A, B, C, D, E, F, G, H, I), B)]
Creates a
Codec[(A, B)]
that first encodes/decodes anA
followed by aB
.Creates a
Codec[(A, B)]
that first encodes/decodes anA
followed by aB
.- Definition Classes
- Codec
-
def
pcontramap[C](f: (C) ⇒ Option[(A, B, C, D, E, F, G, H, I)]): GenCodec[C, (A, B, C, D, E, F, G, H, I)]
Converts this
GenCodec
to aGenCodec[C, B]
using the supplied partial function fromC
toA
. -
def
polyxmap[B](p: Poly, q: Poly)(implicit aToB: Aux[p.type, ::[(A, B, C, D, E, F, G, H, I), HNil], B], bToA: Aux[q.type, ::[B, HNil], (A, B, C, D, E, F, G, H, I)]): Codec[B]
Polymorphic function version of
xmap
.Polymorphic function version of
xmap
.When called on a
Codec[A]
whereA
is not a subytpe ofHList
, returns a new codec that's the result of xmapping withp
andq
, usingp
to convert fromA
toB
and usingq
to convert fromB
toA
.- p
polymorphic function that converts from
A
toB
- q
polymorphic function that converts from
B
toA
- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to ValueCodecEnrichedWithGenericSupport[(A, B, C, D, E, F, G, H, I)] performed by method ValueCodecEnrichedWithGenericSupport in scodec.
- Definition Classes
- ValueCodecEnrichedWithGenericSupport
-
def
polyxmap1[B](p: Poly)(implicit aToB: Aux[p.type, ::[(A, B, C, D, E, F, G, H, I), HNil], B], bToA: Aux[p.type, ::[B, HNil], (A, B, C, D, E, F, G, H, I)]): Codec[B]
Polymorphic function version of
xmap
that uses a single polymorphic function in both directions.Polymorphic function version of
xmap
that uses a single polymorphic function in both directions.When called on a
Codec[A]
whereA
is not a subytpe ofHList
, returns a new codec that's the result of xmapping withp
for both forward and reverse directions.- p
polymorphic function that converts from
A
toB
and fromB
toA
- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to ValueCodecEnrichedWithGenericSupport[(A, B, C, D, E, F, G, H, I)] performed by method ValueCodecEnrichedWithGenericSupport in scodec.
- Definition Classes
- ValueCodecEnrichedWithGenericSupport
-
def
selectEncoder[A](implicit inj: Inject[Coproduct with (A, B, C, D, E, F, G, H, I), A]): Encoder[A]
When called on a
Encoder[C]
whereC
is a coproduct containing typeA
, converts to anEncoder[A]
.When called on a
Encoder[C]
whereC
is a coproduct containing typeA
, converts to anEncoder[A]
.- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to EnrichedCoproductEncoder[Coproduct with (A, B, C, D, E, F, G, H, I)] performed by method EnrichedCoproductEncoder in scodec.
- Definition Classes
- EnrichedCoproductEncoder
-
def
sizeBound: SizeBound
Provides a bound on the size of successfully encoded values.
Provides a bound on the size of successfully encoded values.
- Definition Classes
- Tuple9Codec → Encoder
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toField[K]: Codec[FieldType[K, (A, B, C, D, E, F, G, H, I)]]
Lifts this codec to a codec of a shapeless field -- allowing it to be used in records and unions.
Lifts this codec to a codec of a shapeless field -- allowing it to be used in records and unions.
- Definition Classes
- Codec
-
def
toFieldWithContext[K <: Symbol](k: K): Codec[FieldType[K, (A, B, C, D, E, F, G, H, I)]]
Lifts this codec to a codec of a shapeless field -- allowing it to be used in records and unions.
Lifts this codec to a codec of a shapeless field -- allowing it to be used in records and unions. The specified key is pushed in to the context of any errors that are returned from the resulting codec.
- Definition Classes
- Codec
-
def
toString(): String
- Definition Classes
- Tuple9Codec → AnyRef → Any
-
final
def
unit(zero: (A, B, C, D, E, F, G, H, I)): Codec[Unit]
Converts this to a
Codec[Unit]
that encodes using the specified zero value and decodes a unit value when this codec decodes anA
successfully.Converts this to a
Codec[Unit]
that encodes using the specified zero value and decodes a unit value when this codec decodes anA
successfully.- Definition Classes
- Codec
-
final
def
upcast[B >: (A, B, C, D, E, F, G, H, I)](implicit ta: Typeable[(A, B, C, D, E, F, G, H, I)]): Codec[B]
Safely lifts this codec to a codec of a supertype.
Safely lifts this codec to a codec of a supertype.
When a subtype of
B
that is not a subtype ofA
is passed to encode, an encoding error is returned.- Definition Classes
- Codec
-
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( ... )
-
final
def
widen[B](f: ((A, B, C, D, E, F, G, H, I)) ⇒ B, g: (B) ⇒ Attempt[(A, B, C, D, E, F, G, H, I)]): Codec[B]
Transforms using two functions,
A => B
andB => Attempt[A]
.Transforms using two functions,
A => B
andB => Attempt[A]
.The supplied functions form an injection from
A
toB
. Hence, this method converts from a smaller to a larger type. Hence, the namewiden
.- Definition Classes
- Codec
- def widenAs[X](to: (A, B, C, D, E, F, G, H, I) ⇒ X, from: (X) ⇒ Option[(A, B, C, D, E, F, G, H, I)]): Codec[X]
-
def
widenOpt[B](f: ((A, B, C, D, E, F, G, H, I)) ⇒ B, g: (B) ⇒ Option[(A, B, C, D, E, F, G, H, I)]): Codec[B]
Transforms using two functions,
A => B
andB => Option[A]
.Transforms using two functions,
A => B
andB => Option[A]
.Particularly useful when combined with case class apply/unapply. E.g.,
widenOpt(fa, Foo.apply, Foo.unapply)
.- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to TransformSyntax[Codec, (A, B, C, D, E, F, G, H, I)] performed by method TransformSyntax in scodec.
- Definition Classes
- TransformSyntax
-
def
widenOptc[B](f: ((A, B, C, D, E, F, G, H, I)) ⇒ B)(g: (B) ⇒ Option[(A, B, C, D, E, F, G, H, I)]): Codec[B]
Curried version of
widenOpt
.Curried version of
widenOpt
.- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to TransformSyntax[Codec, (A, B, C, D, E, F, G, H, I)] performed by method TransformSyntax in scodec.
- Definition Classes
- TransformSyntax
-
def
widenc[B](f: ((A, B, C, D, E, F, G, H, I)) ⇒ B)(g: (B) ⇒ Attempt[(A, B, C, D, E, F, G, H, I)]): Codec[B]
Curried version of
widen
.Curried version of
widen
.- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to TransformSyntax[Codec, (A, B, C, D, E, F, G, H, I)] performed by method TransformSyntax in scodec.
- Definition Classes
- TransformSyntax
-
final
def
withContext(context: String): Codec[(A, B, C, D, E, F, G, H, I)]
Creates a new codec that is functionally equivalent to this codec but pushes the specified context string in to any errors returned from encode or decode.
Creates a new codec that is functionally equivalent to this codec but pushes the specified context string in to any errors returned from encode or decode.
- Definition Classes
- Codec
-
final
def
withToString(str: ⇒ String): Codec[(A, B, C, D, E, F, G, H, I)]
Creates a new codec that is functionally equivalent to this codec but returns the specified string from
toString
.Creates a new codec that is functionally equivalent to this codec but returns the specified string from
toString
.- Definition Classes
- Codec
-
final
def
xmap[B](f: ((A, B, C, D, E, F, G, H, I)) ⇒ B, g: (B) ⇒ (A, B, C, D, E, F, G, H, I)): Codec[B]
Transforms using the isomorphism described by two functions,
A => B
andB => A
.Transforms using the isomorphism described by two functions,
A => B
andB => A
.- Definition Classes
- Codec
-
def
xmapc[B](f: ((A, B, C, D, E, F, G, H, I)) ⇒ B)(g: (B) ⇒ (A, B, C, D, E, F, G, H, I)): Codec[B]
Curried version of
xmap
.Curried version of
xmap
.- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to TransformSyntax[Codec, (A, B, C, D, E, F, G, H, I)] performed by method TransformSyntax in scodec.
- Definition Classes
- TransformSyntax
-
final
def
~[B](codecB: Codec[B]): Codec[((A, B, C, D, E, F, G, H, I), B)]
Creates a
Codec[(A, B)]
that first encodes/decodes anA
followed by aB
.Creates a
Codec[(A, B)]
that first encodes/decodes anA
followed by aB
.Operator alias for pairedWith.
- Definition Classes
- Codec
-
final
def
~>[B](codecB: Codec[B])(implicit ev: =:=[Unit, (A, B, C, D, E, F, G, H, I)]): Codec[B]
Assuming
A
isUnit
, creates aCodec[B]
that: encodes the unit followed by aB
; decodes a unit followed by aB
and discards the decoded unit. - def ~~[J](J: Codec[J]): Tuple10Codec[A, B, C, D, E, F, G, H, I, J]
-
def
→[B](y: B): (Tuple9Codec[A, B, C, D, E, F, G, H, I], B)
- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to ArrowAssoc[Tuple9Codec[A, B, C, D, E, F, G, H, I]] performed by method ArrowAssoc in scala.Predef.
- Definition Classes
- ArrowAssoc
Shadowed Implicit Value Members
-
def
exmap[B](f: ((A, B, C, D, E, F, G, H, I)) ⇒ Attempt[B], g: (B) ⇒ Attempt[(A, B, C, D, E, F, G, H, I)]): Codec[B]
Transforms using two functions,
A => Attempt[B]
andB => Attempt[A]
.Transforms using two functions,
A => Attempt[B]
andB => Attempt[A]
.- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to TransformSyntax[Codec, (A, B, C, D, E, F, G, H, I)] performed by method TransformSyntax in scodec.
- Shadowing
- This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:(tuple9Codec: TransformSyntax[Codec, (A, B, C, D, E, F, G, H, I)]).exmap(f, g)
- Definition Classes
- TransformSyntax
-
def
narrow[B](f: ((A, B, C, D, E, F, G, H, I)) ⇒ Attempt[B], g: (B) ⇒ (A, B, C, D, E, F, G, H, I)): Codec[B]
Transforms using two functions,
A => Attempt[B]
andB => A
.Transforms using two functions,
A => Attempt[B]
andB => A
.The supplied functions form an injection from
B
toA
. Hence, this method converts from a larger to a smaller type. Hence, the namenarrow
.- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to TransformSyntax[Codec, (A, B, C, D, E, F, G, H, I)] performed by method TransformSyntax in scodec.
- Shadowing
- This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:(tuple9Codec: TransformSyntax[Codec, (A, B, C, D, E, F, G, H, I)]).narrow(f, g)
- Definition Classes
- TransformSyntax
-
val
self: Codec[(A, B, C, D, E, F, G, H, I)]
- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to Tuple2CodecSupport[(A, B, C, D, E, F, G, H, I)] performed by method Tuple2CodecSupport in scodec.
- Shadowing
- This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:(tuple9Codec: Tuple2CodecSupport[(A, B, C, D, E, F, G, H, I)]).self
- Definition Classes
- Tuple2CodecSupport
-
val
self: Encoder[Coproduct with (A, B, C, D, E, F, G, H, I)]
- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to EnrichedCoproductEncoder[Coproduct with (A, B, C, D, E, F, G, H, I)] performed by method EnrichedCoproductEncoder in scodec.
- Shadowing
- This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:(tuple9Codec: EnrichedCoproductEncoder[Coproduct with (A, B, C, D, E, F, G, H, I)]).self
- Definition Classes
- EnrichedCoproductEncoder
-
val
self: Codec[(A, B, C, D, E, F, G, H, I)]
- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to ValueCodecEnrichedWithGenericSupport[(A, B, C, D, E, F, G, H, I)] performed by method ValueCodecEnrichedWithGenericSupport in scodec.
- Shadowing
- This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:(tuple9Codec: ValueCodecEnrichedWithGenericSupport[(A, B, C, D, E, F, G, H, I)]).self
- Definition Classes
- ValueCodecEnrichedWithGenericSupport
-
val
self: Codec[(A, B, C, D, E, F, G, H, I)]
- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to ValueCodecEnrichedWithHListSupport[(A, B, C, D, E, F, G, H, I)] performed by method ValueCodecEnrichedWithHListSupport in scodec.
- Shadowing
- This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:(tuple9Codec: ValueCodecEnrichedWithHListSupport[(A, B, C, D, E, F, G, H, I)]).self
- Definition Classes
- ValueCodecEnrichedWithHListSupport
-
val
self: Codec[(A, B, C, D, E, F, G, H, I)]
Supports TransformSyntax.
Supports TransformSyntax.
- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to TransformSyntax[Codec, (A, B, C, D, E, F, G, H, I)] performed by method TransformSyntax in scodec.
- Shadowing
- This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
To access this member you can use a type ascription:(tuple9Codec: TransformSyntax[Codec, (A, B, C, D, E, F, G, H, I)]).self
- Definition Classes
- TransformSyntax
-
def
widen[B](f: ((A, B, C, D, E, F, G, H, I)) ⇒ B, g: (B) ⇒ Attempt[(A, B, C, D, E, F, G, H, I)]): Codec[B]
Transforms using two functions,
A => B
andB => Attempt[A]
.Transforms using two functions,
A => B
andB => Attempt[A]
.The supplied functions form an injection from
A
toB
. Hence, this method converts from a smaller to a larger type. Hence, the namewiden
.- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to TransformSyntax[Codec, (A, B, C, D, E, F, G, H, I)] performed by method TransformSyntax in scodec.
- Shadowing
- This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:(tuple9Codec: TransformSyntax[Codec, (A, B, C, D, E, F, G, H, I)]).widen(f, g)
- Definition Classes
- TransformSyntax
-
def
xmap[B](f: ((A, B, C, D, E, F, G, H, I)) ⇒ B, g: (B) ⇒ (A, B, C, D, E, F, G, H, I)): Codec[B]
Transforms using the isomorphism described by two functions,
A => B
andB => A
.Transforms using the isomorphism described by two functions,
A => B
andB => A
.- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to TransformSyntax[Codec, (A, B, C, D, E, F, G, H, I)] performed by method TransformSyntax in scodec.
- Shadowing
- This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:(tuple9Codec: TransformSyntax[Codec, (A, B, C, D, E, F, G, H, I)]).xmap(f, g)
- Definition Classes
- TransformSyntax
-
def
~[B](b: B): (Tuple9Codec[A, B, C, D, E, F, G, H, I], B)
- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to ValueEnrichedWithTuplingSupport[Tuple9Codec[A, B, C, D, E, F, G, H, I]] performed by method ValueEnrichedWithTuplingSupport in scodec.codecs.
- Shadowing
- This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:(tuple9Codec: ValueEnrichedWithTuplingSupport[Tuple9Codec[A, B, C, D, E, F, G, H, I]]).~(b)
- Definition Classes
- ValueEnrichedWithTuplingSupport
-
def
~~[B](B: Codec[B]): TupleCodec[(A, B, C, D, E, F, G, H, I), B]
- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to Tuple2CodecSupport[(A, B, C, D, E, F, G, H, I)] performed by method Tuple2CodecSupport in scodec.
- Shadowing
- This implicitly inherited member is shadowed by one or more members in this class.
To access this member you can use a type ascription:(tuple9Codec: Tuple2CodecSupport[(A, B, C, D, E, F, G, H, I)]).~~(B)
- Definition Classes
- Tuple2CodecSupport
Deprecated Value Members
-
def
pxmap[B](f: ((A, B, C, D, E, F, G, H, I)) ⇒ B, g: (B) ⇒ Option[(A, B, C, D, E, F, G, H, I)]): Codec[B]
Transforms using two functions,
A => B
andB => Option[A]
.Transforms using two functions,
A => B
andB => Option[A]
.Particularly useful when combined with case class apply/unapply. E.g.,
pxmap(fa, Foo.apply, Foo.unapply)
.- Implicit
- This member is added by an implicit conversion from Tuple9Codec[A, B, C, D, E, F, G, H, I] to TransformSyntax[Codec, (A, B, C, D, E, F, G, H, I)] performed by method TransformSyntax in scodec.
- Definition Classes
- TransformSyntax
- Annotations
- @deprecated
- Deprecated
(Since version 1.7.0) Use widenOpt instead