scodec-core/scodec/Codec$

Codec

object Codec extends EncoderFunctions with DecoderFunctions
Companion for Codec.
Companion
class
class Object
trait Matchable
class Any

Document{}

def apply[A](encoder: A => Attempt[BitVector], decoder: BitVector => Attempt[DecodeResult[A]]): Codec[A]
Creates a codec from encoder and decoder functions.
def apply[A](encoder: Encoder[A], decoder: Decoder[A]): Codec[A]
Creates a codec from an encoder and a decoder.
def lazily[A](codec: => Codec[A]): Codec[A]
Provides a Codec[A] that delegates to a lazily evaluated Codec[A].
Typically used to consruct codecs for recursive structures.
inline def flatAppend[A <: Tuple, B](f: A => Codec[B]): Codec[Concat[A, B *: EmptyTuple]]
When called on a Codec[A] for some A <: Tuple, returns a new codec that encodes/decodes
the tuple A followed by the value B, where the latter is encoded/decoded with the codec
returned from applying A to f.
def ::[A, B <: Tuple](codecB: Codec[B]): Codec[A *: B]
Builds a Codec[A *: B] from a Codec[A] and a Codec[B] where B is a tuple type.
That is, this operator is a codec-level tuple prepend operation.
Value Params
codec
codec to prepend
inline def :+[A, B <: Tuple](codecA: Codec[A]): Codec[Concat[B, A *: EmptyTuple]]
codecB :+ codecA returns a new codec that encodes/decodes the tuple B followed by an A.
That is, this operator is a codec-level tuple append operation.
inline def ++[A <: Tuple, B <: Tuple](codecB: Codec[B]): Codec[Concat[A, B]]
Builds a Codec[A ++ B] from a Codec[A] and a Codec[B] where A and B are tuples.
That is, this operator is a codec-level tuple concat operation.
Value Params
codecA
codec to concat
inline def flatConcat[A <: Tuple, B <: Tuple](f: A => Codec[B]): Codec[Concat[A, B]]
When called on a Codec[A] for some A <: Tuple, returns a new codec that encodes/decodes
the tuple A followed by the tuple B, where the latter is encoded/decoded with the codec
returned from applying A to f.
def ::[A, B](b: Codec[B])(using DummyImplicit): Codec[(A, B)]
When called on a Codec[A] where A is not a tuple, creates a new codec that encodes/decodes a tuple of (B, A).
For example,
{{{
uint8 :: utf8
}}}
has type Codec[(Int, Int)].
uint8 :: utf8
}}}
def flatPrepend[A, B <: Tuple](f: A => Codec[B]): Codec[A *: B]
Creates a new codec that encodes/decodes a tuple of A :: B given a function A => Codec[B].
This allows later parts of a tuple codec to be dependent on earlier values.
final def choiceEncoder[A](encoders: Encoder[A]*): Encoder[A]
Creates an encoder that encodes with each of the specified encoders, returning
the first successful result.
Inhertied from
EncoderFunctions
final def encode[A](a: A)(using encA: Encoder[A]): Attempt[BitVector]
Encodes the specified value using the implicit Encoder[A].
Inhertied from
EncoderFunctions
final def decodeBoth[A, B](decA: Decoder[A], decB: Decoder[B])(buffer: BitVector): Attempt[DecodeResult[(A, B)]]
Decodes a tuple (A, B) by first decoding A and then using the remaining bits to decode B.
Inhertied from
DecoderFunctions
final def decodeBothCombine[A, B, C](decA: Decoder[A], decB: Decoder[B])(buffer: BitVector)(f: (A, B) => C): Attempt[DecodeResult[C]]
Decodes a C by first decoding A and then using the remaining bits to decode B, then applying the decoded values to the specified function to generate a C.
Inhertied from
DecoderFunctions
final def choiceDecoder[A](decoders: Decoder[A]*): Decoder[A]
Creates a decoder that decodes with each of the specified decoders, returning
the first successful result.
Inhertied from
DecoderFunctions
final def encodeBoth[A, B](encA: Encoder[A], encB: Encoder[B])(a: A, b: B): Attempt[BitVector]
Encodes the specified values, one after the other, to a bit vector using the specified encoders.
Inhertied from
EncoderFunctions

Value members

Methods

inline def apply[A](using c: Codec[A]): Codec[A]
def fromTuple[A <: Tuple](a: A)(evidence$1: IsMappedBy[[A] =>> Codec[A]][A]): Codec[InverseMap[A, [A] =>> Codec[A]]]
Constructs a Codec[(A, B, ..., N)] from a tuple (Codec[A], Codec[B], ..., Codec[N]).
inline def derived[A](using m: Of[A]): Codec[A]

Fields

final lazy val Codec_Byte: Codec[Byte]
final lazy val Codec_Short: Codec[Short]
final lazy val Codec_Int: Codec[Int]
final lazy val Codec_Long: Codec[Long]
final lazy val Codec_Float: Codec[Float]
final lazy val Codec_Double: Codec[Double]
final lazy val Codec_String: Codec[String]
final lazy val Codec_Boolean: Codec[Boolean]
final lazy val Codec_BitVector: Codec[BitVector]
final lazy val Codec_ByteVector: Codec[ByteVector]
final lazy val Codec_UUID: Codec[UUID]

Givens

Givens

given given_Transform_Codec: Transform[[A] =>> Codec[A]]

Extensions

Extensions

extension (codecA: Codec[A])
inline def dropUnits[A <: Tuple]: Codec[DropUnits[A]]