scodec-core/scodec.codecs/PaddedVarAlignedCodec

PaddedVarAlignedCodec

class PaddedVarAlignedCodec[A](sizeCodec: Codec[Long], valueCodec: Codec[A], multipleForPadding: Long) extends Codec[A]
trait Codec[A]
trait Decoder[A]
trait Encoder[A]
class Object
trait Matchable
class Any

Document{}

def flatMap[B](f: A => Decoder[B]): Decoder[B]
Converts this decoder to a Decoder[B] using the supplied A => Decoder[B].
Inhertied from
Decoder
def contramap[B](f: B => A): Encoder[B]
Converts this encoder to an Encoder[B] using the supplied B => A.
Inhertied from
Encoder
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 of B is dependent on A.
Inhertied from
Codec
final def <~[B](codecB: Codec[B])(ev: Unit =:= B): Codec[A]
Assuming B is Unit, creates a Codec[A] that: encodes the A followed by a unit;
decodes an A followed by a unit and discards the decoded unit.
Operator alias of dropRight.
Inhertied from
Codec
final def tuple: Codec[A *: EmptyTuple]
Lifts this codec in to a codec of a singleton tuple.
Inhertied from
Codec
final def xmap[B](f: A => B, g: B => A): Codec[B]
Transforms using the isomorphism described by two functions, A => B and B => A.
Inhertied from
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.
Inhertied from
Codec
final def dropRight[B](codecB: Codec[B])(ev: Unit =:= B): Codec[A]
Assuming B is Unit, creates a Codec[A] that: encodes the A followed by a unit;
decodes an A followed by a unit and discards the decoded unit.
Inhertied from
Codec
def pcontramap[B](f: B => Option[A]): Encoder[B]
Converts this encoder to an Encoder[B] using the supplied partial
function from B to A. The encoding will fail for any B that
f maps to None.
Inhertied from
Encoder
def collect[F <: ([_$3] =>> Any), A2 >: A](buffer: BitVector, limit: Option[Int])(factory: Factory[A2, F[A2]]): Attempt[DecodeResult[F[A2]]]
Repeatedly decodes values of type A from the specified vector and returns a collection of the specified type.
Terminates when no more bits are available in the vector or when limit is defined and that many records have been
decoded. Exits upon first decoding error.
Inhertied from
Decoder
def encodeAll(as: Iterable[A]): Attempt[BitVector]
Encodes all elements of the specified sequence and concatenates the results, or returns the first encountered error.
Inhertied from
Encoder
final def exmap[B](f: A => Attempt[B], g: B => Attempt[A]): Codec[B]
Transforms using two functions, A => Attempt[B] and B => Attempt[A].
Inhertied from
Codec
def map[B](f: A => B): Decoder[B]
Converts this decoder to a Decoder[B] using the supplied A => B.
Inhertied from
Decoder
final def dropLeft[B](codecB: Codec[B])(ev: Unit =:= A): Codec[B]
Assuming A is Unit, creates a Codec[B] that: encodes the unit followed by a B;
decodes a unit followed by a B and discards the decoded unit.
Inhertied from
Codec
def econtramap[B](f: B => Attempt[A]): Encoder[B]
Converts this encoder to an Encoder[B] using the supplied B => Attempt[A].
Inhertied from
Encoder
def asEncoder: Encoder[A]
Gets this as an Encoder.
Inhertied from
Encoder
def encodeOnly: Codec[A]
Converts this to a codec that fails decoding with an error.
Inhertied from
Encoder
final def upcast[B >: A](ct: ClassTag[A]): Codec[B]
Safely lifts this codec to a codec of a supertype.
When a subtype of B that is not a subtype of A is passed to encode,
an encoding error is returned.
Inhertied from
Codec
def asDecoder: Decoder[A]
Gets this as a Decoder.
Inhertied from
Decoder
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 of B is dependent on A.
Operator alias for flatZip.
Inhertied from
Codec
final def ~>[B](codecB: Codec[B])(ev: Unit =:= A): Codec[B]
Assuming A is Unit, creates a Codec[B] that: encodes the unit followed by a B;
decodes a unit followed by a B and discards the decoded unit.
Operator alias of dropLeft.
Inhertied from
Codec
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 an A successfully.
Inhertied from
Codec
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.
Inhertied from
Codec
def emap[B](f: A => Attempt[B]): Decoder[B]
Converts this decoder to a Decoder[B] using the supplied A => Attempt[B].
Inhertied from
Decoder
final def consume[B](f: A => Codec[B])(g: B => A): Codec[B]
Similar to flatZip except the A type is not visible in the resulting type -- the binary
effects of the Codec[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) => Flags(x.isDefined, y.isDefined, z.isDefined) }
}
}}}
Inhertied from
Codec
final def decodeAll[B](f: A => B)(zero: B, append: (B, B) => B)(buffer: BitVector): (Option[Err], B)
Repeatedly decodes values of type A from the specified vector, converts each value to a B and appends it to an accumulator of type
B using the supplied zero value and append function. Terminates when no more bits are available in the vector. Exits upon first decoding error.
Returns
tuple consisting of the terminating error if any and the accumulated value
Inhertied from
Decoder
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.
Value Params
bits
bits to decode
Returns
error if value could not be decoded or the decoded value
Inhertied from
Decoder
final def downcast[B <: A](ct: ClassTag[B]): Codec[B]
Safely lifts this codec to a codec of a subtype.
When a supertype of B that is not a supertype of A is decoded,
an decoding error is returned.
Inhertied from
Codec

Value members

Methods

def calculatePadding(i: Long): Long
override def encode(a: A): Attempt[BitVector]
Definition Classes
override def decode(buffer: BitVector): Attempt[DecodeResult[A]]
Definition Classes

Fields

Inherited methods

def as[B](using iso: Iso[A, B]): Codec[B]
Transforms this codec to a Codec[B] if A is isomorphic to B.
This is most commonly used to convert a tuple codec to a case class:
Example
{{{
case class Point(x: Int, y: Int, z: Int)
val c: Codec[(Int, Int, Int)] = int8 :: int8 :: int8
val p: Codec[Point] = c.as[Point]
}}}
Inhertied from
Codec
override def decodeOnly[AA >: A]: Codec[AA]
Definition Classes
Inhertied from
Codec
@deprecated("Use .tuple instead", "2.0.0")
final def hlist: Codec[A *: EmptyTuple]
Inhertied from
Codec
def scodec$Codec$$super$decodeOnly[AA >: A]: Codec[AA]
Inhertied from
Codec
final override def compact: Codec[A]
Definition Classes
Inhertied from
Codec
final override def complete: Codec[A]
Definition Classes
Inhertied from
Codec