final class DiscriminatorCodec[A, B] extends Codec[A] with KnownDiscriminatorType[B]
Codec that supports the binary structure tag ++ value
where the tag
identifies the encoding/decoding of
the value.
To build an instance of this codec, call discriminated and specify the tag type via the by
method. Then
call one more more of the case combinators on this class.
Each of the case combinators provides two forms, one that defines a case with a single tag value and another, overloaded form that defines a case with a tag value to use in encoding and a predicate on tag value to use in decoding.
The most general case combinators are caseO
and caseP
(and their operator equivalents, ?
and |
).
In addition to a tag or tag/predicate pair, the caseO
combinators are defined by providing a mapping from
A
to Option[R]
, a mapping from R
to A
, and a Codec[R]
. The case is used for encoding if the
mapping from A
to Option[R]
returns a Some
and it is used for decoding upon matching the tag value.
The caseP
combinators work the same but take a PartialFunction[A, R]
instead of an A => Option[R]
.
If R
is a subtype of A
, then the mapping from R
to A
can be omitted. Hence, the
subcaseO
and subcaseP
(and the operator equivalents, /
and \
) constrain R
to being a subtype
of A
and do not take a R => A
function.
Finally, the least generic case combinators are the typecase
combinators which add further constraints
to the subcase*
combinators. Specifically, the typecase operators omit the A => Option[R]
or
PartialFunction[A, R]
in favor of doing subtype checks. For example, the following codec is a Codec[AnyVal]
that encodes a 0 if passed a Boolean
and a 1 if passed an Int
:
discriminated[AnyVal].by(uint8).typecase(0, bool).typecase(1, int32)
Often, the values are size-delimited -- that is, there is a size
field after the tag
field and before
the
value field. To support this, use the
framing method to provide a transformation to each
value codec. For example,
framing(new CodecTransformation { def apply[X](c: Codec[X]) = variableSizeBytes(uint8, c) }).
- Source
- DiscriminatorCodec.scala
- See also
- Grouped
- Alphabetic
- By Inheritance
- DiscriminatorCodec
- KnownDiscriminatorType
- Codec
- GenCodec
- Decoder
- Encoder
- AnyRef
- Any
- by Tuple2CodecSupport
- by EnrichedCoproductDecoder
- by EnrichedCoproductEncoder
- by ValueCodecEnrichedWithGenericSupport
- by ValueCodecEnrichedWithHListSupport
- by HListCodecEnrichedWithHListSupport
- by TransformSyntax
- by ValueEnrichedWithTuplingSupport
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
- Public
- Protected
Type Members
- case class UnknownDiscriminator(discriminator: D, context: List[String]) extends Err with Product with Serializable
Error raised when an unknown discriminator is encountered when decoding.
Error raised when an unknown discriminator is encountered when decoding.
- Definition Classes
- KnownDiscriminatorType
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 DiscriminatorCodec[A, B] toany2stringadd[DiscriminatorCodec[A, B]] performed by method any2stringadd in scala.Predef.
- Definition Classes
- any2stringadd
- def ->[B](y: B): (DiscriminatorCodec[A, B], B)
- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toArrowAssoc[DiscriminatorCodec[A, B]] performed by method ArrowAssoc in scala.Predef.
- Definition Classes
- ArrowAssoc
- Annotations
- @inline()
- def /[R <: A](encodeTag: B, decodeTag: (B) => Boolean)(toRep: (A) => Option[R])(cr: Codec[R]): DiscriminatorCodec[A, B]
Returns a new discriminator codec with a new case added for the specified tag.
Returns a new discriminator codec with a new case added for the specified tag. Operator alias for
subcaseO
.- R
representative type that this case handles
- encodeTag
tag value to use during encoding for this case
- decodeTag
function that determines if this case should be used for decoding given a decoded tag
- toRep
function used during encoding that converts an
A
to anOption[R]
- cr
codec that encodes/decodes
R
s
- def /[R <: A](tag: B)(toRep: (A) => Option[R])(cr: Codec[R]): DiscriminatorCodec[A, B]
Returns a new discriminator codec with a new case added for the specified tag.
Returns a new discriminator codec with a new case added for the specified tag. Operator alias for
subcaseO
.- R
representative type that this case handles
- tag
tag value for this case
- toRep
function used during encoding that converts an
A
to anOption[R]
- cr
codec that encodes/decodes
R
s
- def :+[B, LB <: HList](codec: Codec[B])(implicit prepend: shapeless.ops.hlist.Prepend.Aux[A, ::[B, HNil], LB], init: Aux[LB, A], last: Aux[LB, B]): Codec[LB]
When called on a
Codec[L]
for someL <: HList
, returns a new codec that encodes/decodes theHList L
followed by aB
.When called on a
Codec[L]
for someL <: HList
, returns a new codec that encodes/decodes theHList L
followed by aB
. That is, this operator is a codec-levelHList
append operation.- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toHListCodecEnrichedWithHListSupport[A] performed by method HListCodecEnrichedWithHListSupport in scodec.This conversion will take place only if A is a subclass of HList (A <: HList).
- Definition Classes
- HListCodecEnrichedWithHListSupport
- def :+:[B](left: Codec[B]): CoproductCodecBuilder[:+:[B, :+:[A, CNil]], ::[Codec[B], ::[Codec[A], HNil]], :+:[B, :+:[A, 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, 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 DiscriminatorCodec[A, B] toValueCodecEnrichedWithHListSupport[A] performed by method ValueCodecEnrichedWithHListSupport in scodec.
- Definition Classes
- ValueCodecEnrichedWithHListSupport
- def ::[B](codec: Codec[B]): Codec[::[B, A]]
When called on a
Codec[L]
for someL <: HList
, returns a new codec representingCodec[B :: L]
.When called on a
Codec[L]
for someL <: HList
, returns a new codec representingCodec[B :: L]
. That is, this operator is a codec-levelHList
prepend operation.- codec
codec to prepend
- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toHListCodecEnrichedWithHListSupport[A] performed by method HListCodecEnrichedWithHListSupport in scodec.This conversion will take place only if A is a subclass of HList (A <: HList).
- Definition Classes
- HListCodecEnrichedWithHListSupport
- def :::[K <: HList, KL <: HList, KLen <: Nat](k: Codec[K])(implicit prepend: shapeless.ops.hlist.Prepend.Aux[K, A, KL], lengthK: Aux[K, KLen], split: Aux[KL, KLen, K, A]): Codec[KL]
When called on a
Codec[L]
for someL <: HList
, returns a new codec that encodes/decodes theHList K
followed by theHList L
.When called on a
Codec[L]
for someL <: HList
, returns a new codec that encodes/decodes theHList K
followed by theHList L
.- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toHListCodecEnrichedWithHListSupport[A] performed by method HListCodecEnrichedWithHListSupport in scodec.This conversion will take place only if A is a subclass of HList (A <: HList).
- Definition Classes
- HListCodecEnrichedWithHListSupport
- def :~>:[B](codecB: Codec[B])(implicit ev: =:=[Unit, B]): Codec[::[A, 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 DiscriminatorCodec[A, B] toValueCodecEnrichedWithHListSupport[A] performed by method ValueCodecEnrichedWithHListSupport in scodec.
- Definition Classes
- ValueCodecEnrichedWithHListSupport
- def :~>:[B](codec: Codec[B])(implicit ev: =:=[Unit, B]): Codec[A]
When called on a
Codec[L]
for someL <: HList
, returns a new codec that encodes/decodesB :: L
but only returnsL
.When called on a
Codec[L]
for someL <: HList
, returns a new codec that encodes/decodesB :: L
but only returnsL
. HList equivalent of~>
.- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toHListCodecEnrichedWithHListSupport[A] performed by method HListCodecEnrichedWithHListSupport in scodec.This conversion will take place only if A is a subclass of HList (A <: HList).
- Definition Classes
- HListCodecEnrichedWithHListSupport
- final def <~[B](codecB: Codec[B])(implicit ev: =:=[Unit, B]): Codec[A]
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) => Codec[L]): Codec[::[A, 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 DiscriminatorCodec[A, B] toValueCodecEnrichedWithHListSupport[A] performed by method ValueCodecEnrichedWithHListSupport in scodec.
- Definition Classes
- ValueCodecEnrichedWithHListSupport
- final def >>~[B](f: (A) => Codec[B]): Codec[(A, B)]
Returns a new codec that encodes/decodes a value of type
(A, B)
where the codec ofB
is dependent onA
. - def ?[R](encodeTag: B, decodeTag: (B) => Boolean)(toRep: (A) => Option[R])(fromRep: (R) => A)(cr: Codec[R]): DiscriminatorCodec[A, B]
Returns a new discriminator codec with a new case added for the specified tag.
Returns a new discriminator codec with a new case added for the specified tag. Operator alias for
caseO
.- R
representative type that this case handles
- encodeTag
tag value to use during encoding for this case
- decodeTag
function that determines if this case should be used for decoding given a decoded tag
- toRep
function used during encoding that converts an
A
to anOption[R]
- fromRep
function used during decoding that converts an
R
to anA
- cr
codec that encodes/decodes
R
s
- def ?[R](tag: B)(toRep: (A) => Option[R])(fromRep: (R) => A)(cr: Codec[R]): DiscriminatorCodec[A, B]
Returns a new discriminator codec with a new case added for the specified tag.
Returns a new discriminator codec with a new case added for the specified tag. Operator alias for
caseO
.- R
representative type that this case handles
- tag
tag value for this case
- toRep
function used during encoding that converts an
A
to anOption[R]
- fromRep
function used during decoding that converts an
R
to anA
- cr
codec that encodes/decodes
R
s
- def \[R <: A](encodeTag: B, decodeTag: (B) => Boolean)(toRep: PartialFunction[A, R])(cr: Codec[R]): DiscriminatorCodec[A, B]
Returns a new discriminator codec with a new case added for the specified tag.
Returns a new discriminator codec with a new case added for the specified tag. Operator alias for
subcaseP
.- R
representative type that this case handles
- encodeTag
tag value to use during encoding for this case
- decodeTag
function that determines if this case should be used for decoding given a decoded tag
- toRep
partial function from
A
toR
used during encoding- cr
codec that encodes/decodes
R
s
- def \[R <: A](tag: B)(toRep: PartialFunction[A, R])(cr: Codec[R]): DiscriminatorCodec[A, B]
Returns a new discriminator codec with a new case added for the specified tag.
Returns a new discriminator codec with a new case added for the specified tag. Operator alias for
subcaseP
.- R
representative type that this case handles
- tag
tag value for this case
- toRep
partial function from
A
toR
used during encoding- cr
codec that encodes/decodes
R
s
- val a: DiscriminatorCodec[A, B]
- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toValueEnrichedWithTuplingSupport[DiscriminatorCodec[A, B]] performed by method ValueEnrichedWithTuplingSupport in scodec.codecs.
- Definition Classes
- ValueEnrichedWithTuplingSupport
- def as[B](implicit as: Transformer[B, B]): DiscriminatorCodec[A, 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 DiscriminatorCodec[A, B] toTransformSyntax[[B]DiscriminatorCodec[A, B], B] performed by method TransformSyntax in scodec.This conversion will take place only if an implicit value of type Transform[[B]DiscriminatorCodec[A, B]] is in scope.
- Definition Classes
- TransformSyntax
- an
- def asDecoder: Decoder[A]
Gets this as a
Decoder
.Gets this as a
Decoder
.- Definition Classes
- Decoder
- def asEncoder: Encoder[A]
Gets this as an
Encoder
.Gets this as an
Encoder
.- Definition Classes
- Encoder
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def caseO[R](encodeTag: B, decodeTag: (B) => Boolean)(toRep: (A) => Option[R])(fromRep: (R) => A)(cr: Codec[R]): DiscriminatorCodec[A, B]
Returns a new discriminator codec with a new case added for the specified tag.
Returns a new discriminator codec with a new case added for the specified tag.
- R
representative type that this case handles
- encodeTag
tag value to use during encoding for this case
- decodeTag
function that determines if this case should be used for decoding given a decoded tag
- toRep
function used during encoding that converts an
A
to anOption[R]
- fromRep
function used during decoding that converts an
R
to anA
- cr
codec that encodes/decodes
R
s
- def caseO[R](tag: B)(toRep: (A) => Option[R])(fromRep: (R) => A)(cr: Codec[R]): DiscriminatorCodec[A, B]
Returns a new discriminator codec with a new case added for the specified tag.
Returns a new discriminator codec with a new case added for the specified tag.
- R
representative type that this case handles
- tag
tag value for this case
- toRep
function used during encoding that converts an
A
to anOption[R]
- fromRep
function used during decoding that converts an
R
to anA
- cr
codec that encodes/decodes
R
s
- def caseP[R](encodeTag: B, decodeTag: (B) => Boolean)(toRep: PartialFunction[A, R])(fromRep: (R) => A)(cr: Codec[R]): DiscriminatorCodec[A, B]
Returns a new discriminator codec with a new case added for the specified tag.
Returns a new discriminator codec with a new case added for the specified tag.
- R
representative type that this case handles
- encodeTag
tag value to use during encoding for this case
- decodeTag
function that determines if this case should be used for decoding given a decoded tag
- toRep
partial function from
A
toR
used during encoding- fromRep
function used during decoding that converts an
R
to anA
- cr
codec that encodes/decodes
R
s
- def caseP[R](tag: B)(toRep: PartialFunction[A, R])(fromRep: (R) => A)(cr: Codec[R]): DiscriminatorCodec[A, B]
Returns a new discriminator codec with a new case added for the specified tag.
Returns a new discriminator codec with a new case added for the specified tag.
- R
representative type that this case handles
- tag
tag value for this case
- toRep
partial function from
A
toR
used during encoding- fromRep
function used during decoding that converts an
R
to anA
- cr
codec that encodes/decodes
R
s
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- final def compact: Codec[A]
Converts this codec to a new codec that compacts the encoded bit vector before returning it.
- final def complete: Codec[A]
Converts this codec to a new codec that fails decoding if there are remaining bits.
- final def consume[B](f: (A) => Codec[B])(g: (B) => A): 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): GenCodec[C, A]
Converts this
GenCodec
to aGenCodec[C, B]
using the suppliedC => A
. - def decode(bits: BitVector): Attempt[DecodeResult[A]]
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
- DiscriminatorCodec → Decoder
- def decodeOnly[AA >: A]: Codec[AA]
Converts this to a codec that fails encoding with an error.
- final def decodeValue(bits: BitVector): Attempt[A]
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
- def derive[A]: DeriveHListElementAux[A, A]
Supports building a
Codec[M]
for someHList M
whereM
is theHList
that results in removing the firstA
fromL
.Supports building a
Codec[M]
for someHList M
whereM
is theHList
that results in removing the firstA
fromL
.Example usage:
case class Flags(x: Boolean, y: Boolean, z: Boolean) val c = (bool :: bool :: bool :: ignore(5)).flatPrepend { flgs => conditional(flgs.x, uint8) :: conditional(flgs.y, uint8) :: conditional(flgs.z, uint8) } c.derive[Flags].from { case x :: y :: z :: HNil => Flags(x.isDefined, y.isDefined, z.isDefined) }
This codec, the
Codec[L]
, is used for encoding/decoding. When decoding, the first value of typeA
is removed from theHList
.When encoding, the returned codec computes an
A
value using the supplied function and inserts the computedA
in to theHList M
, yielding anHList L
. ThatHList L
is then encoded using the original codec.This method is called
derive
because the value of typeA
is derived from the other fields in theHList L
.- A
type to remove from
L
and derive from the resulting list
- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toHListCodecEnrichedWithHListSupport[A] performed by method HListCodecEnrichedWithHListSupport in scodec.This conversion will take place only if A is a subclass of HList (A <: HList).
- Definition Classes
- HListCodecEnrichedWithHListSupport
- final def downcast[B <: A](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]): 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]
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 dropUnits[M <: HList](implicit du: Aux[A, M]): Codec[M]
Creates a new codec with all unit values filtered out.
Creates a new codec with all unit values filtered out.
- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toHListCodecEnrichedWithHListSupport[A] performed by method HListCodecEnrichedWithHListSupport in scodec.This conversion will take place only if A is a subclass of HList (A <: HList).
- Definition Classes
- HListCodecEnrichedWithHListSupport
- def econtramap[C](f: (C) => Attempt[A]): GenCodec[C, A]
Converts this
GenCodec
to aGenCodec[C, B]
using the suppliedC => Attempt[A]
. - def emap[C](f: (A) => Attempt[C]): GenCodec[A, C]
Converts this
GenCodec
to aGenCodec[A, C]
using the suppliedB => Attempt[C]
. - def encode(a: A): 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
- DiscriminatorCodec → Encoder
- def encodeOnly: Codec[A]
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: (DiscriminatorCodec[A, B]) => Boolean, msg: => Any): DiscriminatorCodec[A, B]
- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toEnsuring[DiscriminatorCodec[A, B]] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
- def ensuring(cond: (DiscriminatorCodec[A, B]) => Boolean): DiscriminatorCodec[A, B]
- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toEnsuring[DiscriminatorCodec[A, B]] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
- def ensuring(cond: Boolean, msg: => Any): DiscriminatorCodec[A, B]
- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toEnsuring[DiscriminatorCodec[A, B]] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
- def ensuring(cond: Boolean): DiscriminatorCodec[A, B]
- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toEnsuring[DiscriminatorCodec[A, B]] performed by method Ensuring in scala.Predef.
- Definition Classes
- Ensuring
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- final def exmap[B](f: (A) => Attempt[B], g: (B) => Attempt[A]): 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: (B) => Attempt[B])(g: (B) => Attempt[B]): DiscriminatorCodec[A, B]
Curried version of
exmap
.Curried version of
exmap
.- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toTransformSyntax[[B]DiscriminatorCodec[A, B], B] performed by method TransformSyntax in scodec.This conversion will take place only if an implicit value of type Transform[[B]DiscriminatorCodec[A, B]] is in scope.
- Definition Classes
- TransformSyntax
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def flatAppend[A, LA <: HList, Len <: Nat](f: (A) => Codec[A])(implicit prepend: shapeless.ops.hlist.Prepend.Aux[A, ::[A, HNil], LA], length: Aux[A, Len], split: Aux[LA, Len, A, ::[A, HNil]]): Codec[LA]
When called on a
Codec[L]
for someL <: HList
, returns a new codec that encodes/decodes theHList L
followed by the valueA
, where the latter is encoded/decoded with the codec returned from applyingL
tof
.When called on a
Codec[L]
for someL <: HList
, returns a new codec that encodes/decodes theHList L
followed by the valueA
, where the latter is encoded/decoded with the codec returned from applyingL
tof
.- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toHListCodecEnrichedWithHListSupport[A] performed by method HListCodecEnrichedWithHListSupport in scodec.This conversion will take place only if A is a subclass of HList (A <: HList).
- Definition Classes
- HListCodecEnrichedWithHListSupport
- def flatConcat[M <: HList, LM <: HList, LLen <: Nat](f: (A) => Codec[M])(implicit prepend: shapeless.ops.hlist.Prepend.Aux[A, M, LM], lengthK: Aux[A, LLen], split: Aux[LM, LLen, A, M]): Codec[LM]
When called on a
Codec[L]
for someL <: HList
, returns a new codec that encodes/decodes theHList L
followed by theHList M
, where the latter is encoded/decoded with the codec returned from applyingL
tof
.When called on a
Codec[L]
for someL <: HList
, returns a new codec that encodes/decodes theHList L
followed by theHList M
, where the latter is encoded/decoded with the codec returned from applyingL
tof
.- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toHListCodecEnrichedWithHListSupport[A] performed by method HListCodecEnrichedWithHListSupport in scodec.This conversion will take place only if A is a subclass of HList (A <: HList).
- Definition Classes
- HListCodecEnrichedWithHListSupport
- def flatMap[B](f: (A) => 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) => Codec[L]): Codec[::[A, 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 DiscriminatorCodec[A, B] toValueCodecEnrichedWithHListSupport[A] performed by method ValueCodecEnrichedWithHListSupport in scodec.
- Definition Classes
- ValueCodecEnrichedWithHListSupport
- final def flatZip[B](f: (A) => Codec[B]): Codec[(A, 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) => Codec[B]): Codec[::[A, ::[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 DiscriminatorCodec[A, B] toValueCodecEnrichedWithHListSupport[A] performed by method ValueCodecEnrichedWithHListSupport in scodec.
- Definition Classes
- ValueCodecEnrichedWithHListSupport
- final def flattenLeftPairs(implicit f: FlattenLeftPairs[A]): 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 DiscriminatorCodec[A, B] toStringFormat[DiscriminatorCodec[A, B]] performed by method StringFormat in scala.Predef.
- Definition Classes
- StringFormat
- Annotations
- @inline()
- def framing(framing: CodecTransformation): DiscriminatorCodec[A, B]
Replaces the current framing logic with the specified codec transformation.
Replaces the current framing logic with the specified codec transformation.
Every representative codec is wrapped with the framing logic when encoding/decoding.
- framing
new framing logic
- final def fuse[AA <: A, BB >: A](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[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- final def hlist: Codec[::[A, 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) => C): GenCodec[A, C]
Converts this
GenCodec
to aGenCodec[A, C]
using the suppliedB => C
. - final def narrow[B](f: (A) => Attempt[B], g: (B) => A): 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: (B) => Attempt[B])(g: (B) => B): DiscriminatorCodec[A, B]
Curried version of
narrow
.Curried version of
narrow
.- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toTransformSyntax[[B]DiscriminatorCodec[A, B], B] performed by method TransformSyntax in scodec.This conversion will take place only if an implicit value of type Transform[[B]DiscriminatorCodec[A, B]] is in scope.
- Definition Classes
- TransformSyntax
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def pairedWith[B](codecB: Codec[B]): Codec[(A, 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]): GenCodec[C, A]
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, HNil], B], bToA: Aux[q.type, ::[B, HNil], A]): 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 DiscriminatorCodec[A, B] toValueCodecEnrichedWithGenericSupport[A] performed by method ValueCodecEnrichedWithGenericSupport in scodec.
- Definition Classes
- ValueCodecEnrichedWithGenericSupport
- def polyxmap[M <: HList](p: Poly, q: Poly)(implicit lToM: Aux[p.type, A, M], mToL: Aux[q.type, M, A]): Codec[M]
Polymorphic function version of
xmap
.Polymorphic function version of
xmap
.When called on a
Codec[L]
for someL <: HList
, returns a new codec that's the result of xmapping withp
andq
, usingp
to convert fromL
toM
and usingq
to convert fromM
toL
.- p
polymorphic function that converts from
L
toM
- q
polymorphic function that converts from
M
toL
- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toHListCodecEnrichedWithHListSupport[A] performed by method HListCodecEnrichedWithHListSupport in scodec.This conversion will take place only if A is a subclass of HList (A <: HList).
- Definition Classes
- HListCodecEnrichedWithHListSupport
- def polyxmap1[B](p: Poly)(implicit aToB: Aux[p.type, ::[A, HNil], B], bToA: Aux[p.type, ::[B, HNil], A]): 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 DiscriminatorCodec[A, B] toValueCodecEnrichedWithGenericSupport[A] performed by method ValueCodecEnrichedWithGenericSupport in scodec.
- Definition Classes
- ValueCodecEnrichedWithGenericSupport
- def polyxmap1[M <: HList](p: Poly)(implicit m: Aux[p.type, A, M], m2: Aux[p.type, M, A]): Codec[M]
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[L]
for someL <: HList
, returns a new codec that's the result of xmapping withp
for both forward and reverse directions.- p
polymorphic function that converts from
L
toM
and fromM
toL
- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toHListCodecEnrichedWithHListSupport[A] performed by method HListCodecEnrichedWithHListSupport in scodec.This conversion will take place only if A is a subclass of HList (A <: HList).
- Definition Classes
- HListCodecEnrichedWithHListSupport
- def selectDecoder[A](implicit sel: Selector[A, A]): Decoder[Option[A]]
When called on a
Decoder[C]
whereC
is a coproduct containing typeA
, converts to aDecoder[Option[A]]
.When called on a
Decoder[C]
whereC
is a coproduct containing typeA
, converts to aDecoder[Option[A]]
.- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toEnrichedCoproductDecoder[A] performed by method EnrichedCoproductDecoder in scodec.This conversion will take place only if A is a subclass of Coproduct (A <: Coproduct).
- Definition Classes
- EnrichedCoproductDecoder
- def selectEncoder[A](implicit inj: Inject[Coproduct, 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 DiscriminatorCodec[A, B] toEnrichedCoproductEncoder[Coproduct] performed by method EnrichedCoproductEncoder in scodec.This conversion will take place only if A is a superclass of Coproduct (A >: Coproduct).
- 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
- DiscriminatorCodec → Encoder
- def subcaseO[R <: A](encodeTag: B, decodeTag: (B) => Boolean)(toRep: (A) => Option[R])(cr: Codec[R]): DiscriminatorCodec[A, B]
Returns a new discriminator codec with a new case added for the specified tag.
Returns a new discriminator codec with a new case added for the specified tag.
- R
representative type that this case handles
- encodeTag
tag value to use during encoding for this case
- decodeTag
function that determines if this case should be used for decoding given a decoded tag
- toRep
function used during encoding that converts an
A
to anOption[R]
- cr
codec that encodes/decodes
R
s
- def subcaseO[R <: A](tag: B)(toRep: (A) => Option[R])(cr: Codec[R]): DiscriminatorCodec[A, B]
Returns a new discriminator codec with a new case added for the specified tag.
Returns a new discriminator codec with a new case added for the specified tag.
- R
representative type that this case handles
- tag
tag value for this case
- toRep
function used during encoding that converts an
A
to anOption[R]
- cr
codec that encodes/decodes
R
s
- def subcaseP[R <: A](encodeTag: B, decodeTag: (B) => Boolean)(toRep: PartialFunction[A, R])(cr: Codec[R]): DiscriminatorCodec[A, B]
Returns a new discriminator codec with a new case added for the specified tag.
Returns a new discriminator codec with a new case added for the specified tag.
- R
representative type that this case handles
- encodeTag
tag value to use during encoding for this case
- decodeTag
function that determines if this case should be used for decoding given a decoded tag
- toRep
partial function from
A
toR
used during encoding- cr
codec that encodes/decodes
R
s
- def subcaseP[R <: A](tag: B)(toRep: PartialFunction[A, R])(cr: Codec[R]): DiscriminatorCodec[A, B]
Returns a new discriminator codec with a new case added for the specified tag.
Returns a new discriminator codec with a new case added for the specified tag.
- R
representative type that this case handles
- tag
tag value for this case
- toRep
partial function from
A
toR
used during encoding- cr
codec that encodes/decodes
R
s
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toField[K]: Codec[FieldType[K, A]]
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]]
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
- DiscriminatorCodec → AnyRef → Any
- def typecase[R <: A](encodeTag: B, decodeTag: (B) => Boolean, cr: Codec[R])(implicit arg0: ClassTag[R]): DiscriminatorCodec[A, B]
Returns a new discriminator codec with a new case added for the specified tag.
Returns a new discriminator codec with a new case added for the specified tag.
Note: when encoding a value of
A
, this combinator compares the runtime class of that value to the runtime class of the suppliedClassTag[R]
. As such, the *erased* type ofA
is used and hence, this operation is not safe to use with parameterized representation types.- R
representative type that this case handles
- encodeTag
tag value to use during encoding for this case
- decodeTag
function that determines if this case should be used for decoding given a decoded tag
- cr
codec that encodes/decodes
R
s
- def typecase[R <: A](tag: B, cr: Codec[R])(implicit arg0: ClassTag[R]): DiscriminatorCodec[A, B]
Returns a new discriminator codec with a new case added for the specified tag.
Returns a new discriminator codec with a new case added for the specified tag.
Note: when encoding a value of
A
, this combinator compares the runtime class of that value to the runtime class of the suppliedClassTag[R]
. As such, the *erased* type ofA
is used and hence, this operation is not safe to use with parameterized representation types.- R
representative type that this case handles
- tag
tag value for this case
- cr
codec that encodes/decodes
R
s
- final def unit(zero: A): 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](implicit ta: Typeable[A]): 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(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- final def widen[B](f: (A) => B, g: (B) => Attempt[A]): 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 widenOpt[B](f: (B) => B, g: (B) => Option[B]): DiscriminatorCodec[A, 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 DiscriminatorCodec[A, B] toTransformSyntax[[B]DiscriminatorCodec[A, B], B] performed by method TransformSyntax in scodec.This conversion will take place only if an implicit value of type Transform[[B]DiscriminatorCodec[A, B]] is in scope.
- Definition Classes
- TransformSyntax
- def widenOptc[B](f: (B) => B)(g: (B) => Option[B]): DiscriminatorCodec[A, B]
Curried version of
widenOpt
.Curried version of
widenOpt
.- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toTransformSyntax[[B]DiscriminatorCodec[A, B], B] performed by method TransformSyntax in scodec.This conversion will take place only if an implicit value of type Transform[[B]DiscriminatorCodec[A, B]] is in scope.
- Definition Classes
- TransformSyntax
- def widenc[B](f: (B) => B)(g: (B) => Attempt[B]): DiscriminatorCodec[A, B]
Curried version of
widen
.Curried version of
widen
.- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toTransformSyntax[[B]DiscriminatorCodec[A, B], B] performed by method TransformSyntax in scodec.This conversion will take place only if an implicit value of type Transform[[B]DiscriminatorCodec[A, B]] is in scope.
- Definition Classes
- TransformSyntax
- final def withContext(context: String): Codec[A]
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]
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, g: (B) => A): 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: (B) => B)(g: (B) => B): DiscriminatorCodec[A, B]
Curried version of
xmap
.Curried version of
xmap
.- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toTransformSyntax[[B]DiscriminatorCodec[A, B], B] performed by method TransformSyntax in scodec.This conversion will take place only if an implicit value of type Transform[[B]DiscriminatorCodec[A, B]] is in scope.
- Definition Classes
- TransformSyntax
- def |[R](encodeTag: B, decodeTag: (B) => Boolean)(toRep: PartialFunction[A, R])(fromRep: (R) => A)(cr: Codec[R]): DiscriminatorCodec[A, B]
Returns a new discriminator codec with a new case added for the specified tag.
Returns a new discriminator codec with a new case added for the specified tag. Operator alias for
caseP
.- R
representative type that this case handles
- encodeTag
tag value to use during encoding for this case
- decodeTag
function that determines if this case should be used for decoding given a decoded tag
- toRep
partial function from
A
toR
used during encoding- fromRep
function used during decoding that converts an
R
to anA
- cr
codec that encodes/decodes
R
s
- def |[R](tag: B)(toRep: PartialFunction[A, R])(fromRep: (R) => A)(cr: Codec[R]): DiscriminatorCodec[A, B]
Returns a new discriminator codec with a new case added for the specified tag.
Returns a new discriminator codec with a new case added for the specified tag. Operator alias for
caseP
.- R
representative type that this case handles
- tag
tag value for this case
- toRep
partial function from
A
toR
used during encoding- fromRep
function used during decoding that converts an
R
to anA
- cr
codec that encodes/decodes
R
s
- final def ~[B](codecB: Codec[B]): Codec[(A, 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]): 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 ~~[B](B: Codec[B]): TupleCodec[A, B]
- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toTuple2CodecSupport[A] performed by method Tuple2CodecSupport in scodec.
- Definition Classes
- Tuple2CodecSupport
Shadowed Implicit Value Members
- def exmap[B](f: (B) => Attempt[B], g: (B) => Attempt[B]): DiscriminatorCodec[A, 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 DiscriminatorCodec[A, B] toTransformSyntax[[B]DiscriminatorCodec[A, B], B] performed by method TransformSyntax in scodec.This conversion will take place only if an implicit value of type Transform[[B]DiscriminatorCodec[A, B]] is in scope.
- 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:(discriminatorCodec: TransformSyntax[[B]DiscriminatorCodec[A, B], B]).exmap(f, g)
- Definition Classes
- TransformSyntax
- def narrow[B](f: (B) => Attempt[B], g: (B) => B): DiscriminatorCodec[A, 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 DiscriminatorCodec[A, B] toTransformSyntax[[B]DiscriminatorCodec[A, B], B] performed by method TransformSyntax in scodec.This conversion will take place only if an implicit value of type Transform[[B]DiscriminatorCodec[A, B]] is in scope.
- 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:(discriminatorCodec: TransformSyntax[[B]DiscriminatorCodec[A, B], B]).narrow(f, g)
- Definition Classes
- TransformSyntax
- val self: Codec[A]
- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toTuple2CodecSupport[A] 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:(discriminatorCodec: Tuple2CodecSupport[A]).self
- Definition Classes
- Tuple2CodecSupport
- val self: Decoder[A]
- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toEnrichedCoproductDecoder[A] performed by method EnrichedCoproductDecoder in scodec.This conversion will take place only if A is a subclass of Coproduct (A <: Coproduct).
- 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:(discriminatorCodec: EnrichedCoproductDecoder[A]).self
- Definition Classes
- EnrichedCoproductDecoder
- val self: Encoder[Coproduct]
- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toEnrichedCoproductEncoder[Coproduct] performed by method EnrichedCoproductEncoder in scodec.This conversion will take place only if A is a superclass of Coproduct (A >: Coproduct).
- 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:(discriminatorCodec: EnrichedCoproductEncoder[Coproduct]).self
- Definition Classes
- EnrichedCoproductEncoder
- val self: Codec[A]
- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toValueCodecEnrichedWithGenericSupport[A] 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:(discriminatorCodec: ValueCodecEnrichedWithGenericSupport[A]).self
- Definition Classes
- ValueCodecEnrichedWithGenericSupport
- val self: Codec[A]
- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toValueCodecEnrichedWithHListSupport[A] 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:(discriminatorCodec: ValueCodecEnrichedWithHListSupport[A]).self
- Definition Classes
- ValueCodecEnrichedWithHListSupport
- val self: Codec[A]
- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toHListCodecEnrichedWithHListSupport[A] performed by method HListCodecEnrichedWithHListSupport in scodec.This conversion will take place only if A is a subclass of HList (A <: HList).
- 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:(discriminatorCodec: HListCodecEnrichedWithHListSupport[A]).self
- Definition Classes
- HListCodecEnrichedWithHListSupport
- val self: DiscriminatorCodec[A, B]
- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toTransformSyntax[[B]DiscriminatorCodec[A, B], B] performed by method TransformSyntax in scodec.This conversion will take place only if an implicit value of type Transform[[B]DiscriminatorCodec[A, B]] is in scope.
- 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:(discriminatorCodec: TransformSyntax[[B]DiscriminatorCodec[A, B], B]).self
- Definition Classes
- TransformSyntax
- def widen[B](f: (B) => B, g: (B) => Attempt[B]): DiscriminatorCodec[A, 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 DiscriminatorCodec[A, B] toTransformSyntax[[B]DiscriminatorCodec[A, B], B] performed by method TransformSyntax in scodec.This conversion will take place only if an implicit value of type Transform[[B]DiscriminatorCodec[A, B]] is in scope.
- 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:(discriminatorCodec: TransformSyntax[[B]DiscriminatorCodec[A, B], B]).widen(f, g)
- Definition Classes
- TransformSyntax
- def xmap[B](f: (B) => B, g: (B) => B): DiscriminatorCodec[A, 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 DiscriminatorCodec[A, B] toTransformSyntax[[B]DiscriminatorCodec[A, B], B] performed by method TransformSyntax in scodec.This conversion will take place only if an implicit value of type Transform[[B]DiscriminatorCodec[A, B]] is in scope.
- 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:(discriminatorCodec: TransformSyntax[[B]DiscriminatorCodec[A, B], B]).xmap(f, g)
- Definition Classes
- TransformSyntax
- def ~[B](b: B): (DiscriminatorCodec[A, B], B)
- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toValueEnrichedWithTuplingSupport[DiscriminatorCodec[A, B]] 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:(discriminatorCodec: ValueEnrichedWithTuplingSupport[DiscriminatorCodec[A, B]]).~(b)
- Definition Classes
- ValueEnrichedWithTuplingSupport
Deprecated Value Members
- def pxmap[B](f: (B) => B, g: (B) => Option[B]): DiscriminatorCodec[A, 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 DiscriminatorCodec[A, B] toTransformSyntax[[B]DiscriminatorCodec[A, B], B] performed by method TransformSyntax in scodec.This conversion will take place only if an implicit value of type Transform[[B]DiscriminatorCodec[A, B]] is in scope.
- Definition Classes
- TransformSyntax
- Annotations
- @deprecated
- Deprecated
(Since version 1.7.0) Use widenOpt instead
- def →[B](y: B): (DiscriminatorCodec[A, B], B)
- Implicit
- This member is added by an implicit conversion from DiscriminatorCodec[A, B] toArrowAssoc[DiscriminatorCodec[A, B]] performed by method ArrowAssoc in scala.Predef.
- Definition Classes
- ArrowAssoc
- Annotations
- @deprecated
- Deprecated
(Since version 2.13.0) Use
->
instead. If you still wish to display it as one character, consider using a font with programming ligatures such as Fira Code.