trait Codec[E, D, F, T] extends Decoder[E, D, F, T] with Encoder[E, D, T]
Combines a Decoder and an Encoder.
Codecs are only meant as a convenience, and should not be considered more powerful or desirable than encoders or decoders. Some types can be both encoded to and decoded from, and being able to define both instances in one call is convenient. It's however very poor practice to request a type to have a Codec instance - a much preferred alternative would be to require it to have a Decoder and an Encoder instance, which a Codec would fulfill.
- Source
- Codec.scala
- Alphabetic
- By Inheritance
- Codec
- Encoder
- Decoder
- Serializable
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Abstract Value Members
- abstract def decode(e: E): Either[F, D]
Decodes encoded data.
Decodes encoded data.
This method is safe, in that it won't throw for run-of-the-mill errors. Unrecoverable errors such as out of memory exceptions are still thrown, but that's considered valid exceptional cases, where incorrectly encoded data is just... normal.
Callers that wish to fail fast and fail hard can use the unsafeDecode method instead.
- Definition Classes
- Decoder
- abstract def encode(d: D): E
Encodes the specified value.
Encodes the specified value.
- Definition Classes
- Encoder
Concrete Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def andThen[FF, DD](f: (Either[F, D]) => Either[FF, DD]): Decoder[E, DD, FF, T]
Creates a new Decoder instance by transforming raw results with the specified function.
Creates a new Decoder instance by transforming raw results with the specified function.
Most of the time, other combinators such as map should be preferred. andThen is mostly useful when one needs to turn failures into successes, and even then, recover or recoverWith are probably more directly useful.
- Definition Classes
- Decoder
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def collect[DD](f: PartialFunction[D, DD])(implicit t: IsError[F]): Decoder[E, DD, F, T]
Applies the specified partial function, turning all non-matches to failures.
- def contramap[DD](f: (DD) => D): Encoder[E, DD, T]
Creates a new Encoder instances that applies the specified function before encoding.
Creates a new Encoder instances that applies the specified function before encoding.
This is a convenient way of creating Encoder instances: if you already have an
Encoder[E, D, R], need to write anEncoder[E, DD, R]and know how to turn aDDinto aD, you need but call contramap.- Definition Classes
- Encoder
- def contramapEncoded[EE](f: (EE) => E): Decoder[EE, D, F, T]
Creates a new Decoder instance by transforming encoded values with the specified function.
- def emap[DD](f: (D) => Either[F, DD]): Decoder[E, DD, F, T]
Creates a new Decoder instance by transforming successful results with the specified function.
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def filter(f: (D) => Boolean)(implicit t: IsError[F]): Decoder[E, D, F, T]
Turns all values that don't match the specified predicates into failures.
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def flatMap[DD](f: (D) => Decoder[E, DD, F, T]): Decoder[E, DD, F, T]
- Definition Classes
- Decoder
- Annotations
- @SuppressWarnings()
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def handleErrorWith(f: (F) => Decoder[E, D, F, T]): Decoder[E, D, F, T]
- Definition Classes
- Decoder
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def imap[DD](f: (D) => DD)(g: (DD) => D): Codec[E, DD, F, T]
- def imapEncoded[EE](f: (E) => EE)(g: (EE) => E): Codec[EE, D, F, T]
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def leftMap[FF](f: (F) => FF): Codec[E, D, FF, T]
Creates a new Decoder instance by transforming errors with the specified function.
- def map[DD](f: (D) => DD): Decoder[E, DD, F, T]
Creates a new Decoder instance by transforming successful results with the specified function.
- def mapEncoded[EE](f: (E) => EE): Encoder[EE, D, T]
- Definition Classes
- Encoder
- 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()
- def orElse[DD >: D](d: Decoder[E, DD, F, T]): Decoder[E, DD, F, T]
Creates a new Decoder instance with a fallback decoder if the current one fails.
- def product[DD](decoder: Decoder[E, DD, F, T]): Decoder[E, (D, DD), F, T]
- Definition Classes
- Decoder
- def recover[DD >: D](pf: PartialFunction[F, DD]): Decoder[E, DD, F, T]
Creates a new Decoder instance by transforming some failures into successes with the specified function.
- def recoverWith[DD >: D, FF >: F](pf: PartialFunction[F, Either[FF, DD]]): Decoder[E, DD, FF, T]
Creates a new Decoder instance by transforming some failures with the specified function.
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def tag[TT]: Codec[E, D, F, TT]
Changes the type with which the decoder is tagged.
Changes the type with which the decoder is tagged.
This makes it possible to share similar decoders across various libraries. Extracting values from strings, for example, is a common task for which the default implementation can be shared rather than copy / pasted.
- def toString(): String
- Definition Classes
- AnyRef → Any
- def unsafeDecode(e: E): D
Decodes encoded data unsafely.
Decodes encoded data unsafely.
The main difference between this and decode is that the former throws exceptions when errors occur where the later safely encodes error conditions in its return type.
decode should almost always be preferred, but this can be useful for code where crashing is an acceptable reaction to failure.
- Definition Classes
- Decoder
- Annotations
- @SuppressWarnings()
- 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()