Codec

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 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.

Inherited 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.

Inherited 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.

Inherited from
DecoderFunctions
final def encode[A](a: A)(using encA: Encoder[A]): Attempt[BitVector]

Encodes the specified value using the given Encoder[A].

Inherited from
EncoderFunctions
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.

Inherited from
EncoderFunctions
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.

Inherited from
DecoderFunctions

Value members

Methods

inline def apply[A](using c: Codec[A]): Codec[A]
inline def derived[A](using m: Of[A]): Codec[A]
def fromTuple[A <: Tuple](a: A)(using `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]).

Fields

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

Givens

Extensions

Extensions

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