Codec<A> class

A Codec is a product of an Encoder and a Decoder. It provides the functionality of converting between values of type A and JSON.

It mainly exists to make building encoders/decoders more convenient.

Constructors

Codec(Decoder<A> decoder, Encoder<A> encoder)

const

Properties

decoder → Decoder<A>

final

encoder → Encoder<A>

final

hashCode → int

The hash code for this object.

no setter, inherited

nullable → Codec<A?>

no setter

optional → Codec<Option<A>>

no setter

runtimeType → Type

A representation of the runtime type of the object.

no setter, inherited

Methods

at(String key) → Codec<A>

/////////////////////////////////////////////////////////////////////////// /////////////////////////// Codec combinators ///////////////////////////// ///////////////////////////////////////////////////////////////////////////

decode(dynamic json) → DecodeResult<A>

encode(A a) → dynamic

ensure(bool predicate(A), String message) → Codec<A>

/////////////////////////////////////////////////////////////////////////// ///////////////////////// Decoder combinators ///////////////////////////// ///////////////////////////////////////////////////////////////////////////

exmap<B>(Either<DecodingError, B> f(A), A g(B)) → Codec<B>

noSuchMethod(Invocation invocation) → dynamic

Invoked when a nonexistent method or property is accessed.

inherited

recover(A a) → Codec<A>

recoverWith(Codec<A> other) → Codec<A>

toString() → String

A string representation of this object.

inherited

withDefault(A a) → Codec<A>

withErrorMessage(String message) → Codec<A>

xmap<B>(B f(A), A g(B)) → Codec<B>

Operators

operator ==(Object other) → bool

The equality operator.

inherited

Static Properties

bigint ↔ Codec<BigInt>

/////////////////////////////////////////////////////////////////////////// ////////////////////////////// Primitives ///////////////////////////////// ///////////////////////////////////////////////////////////////////////////

getter/setter pair

boolean ↔ Codec<bool>

getter/setter pair

dateTime ↔ Codec<DateTime>

getter/setter pair

dubble ↔ Codec<double>

getter/setter pair

duration ↔ Codec<Duration>

getter/setter pair

integer ↔ Codec<int>

getter/setter pair

number ↔ Codec<num>

getter/setter pair

object ↔ Codec<Map<String, dynamic>>

getter/setter pair

string ↔ Codec<String>

getter/setter pair

Static Methods

forProduct10<A, B, C, D, E, F, G, H, I, J, K>(Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH, Codec<I> codecI, Codec<J> codecJ, Codec<K> codecK, A apply(B, C, D, E, F, G, H, I, J, K), Tuple10<B, C, D, E, F, G, H, I, J, K> tupled(A)) → Codec<A>

forProduct11<A, B, C, D, E, F, G, H, I, J, K, L>(Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH, Codec<I> codecI, Codec<J> codecJ, Codec<K> codecK, Codec<L> codecL, A apply(B, C, D, E, F, G, H, I, J, K, L), Tuple11<B, C, D, E, F, G, H, I, J, K, L> tupled(A)) → Codec<A>

forProduct12<A, B, C, D, E, F, G, H, I, J, K, L, M>(Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH, Codec<I> codecI, Codec<J> codecJ, Codec<K> codecK, Codec<L> codecL, Codec<M> codecM, A apply(B, C, D, E, F, G, H, I, J, K, L, M), Tuple12<B, C, D, E, F, G, H, I, J, K, L, M> tupled(A)) → Codec<A>

forProduct13<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH, Codec<I> codecI, Codec<J> codecJ, Codec<K> codecK, Codec<L> codecL, Codec<M> codecM, Codec<N> codecN, A apply(B, C, D, E, F, G, H, I, J, K, L, M, N), Tuple13<B, C, D, E, F, G, H, I, J, K, L, M, N> tupled(A)) → Codec<A>

forProduct14<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH, Codec<I> codecI, Codec<J> codecJ, Codec<K> codecK, Codec<L> codecL, Codec<M> codecM, Codec<N> codecN, Codec<O> codecO, A apply(B, C, D, E, F, G, H, I, J, K, L, M, N, O), Tuple14<B, C, D, E, F, G, H, I, J, K, L, M, N, O> tupled(A)) → Codec<A>

forProduct15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH, Codec<I> codecI, Codec<J> codecJ, Codec<K> codecK, Codec<L> codecL, Codec<M> codecM, Codec<N> codecN, Codec<O> codecO, Codec<P> codecP, A apply(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P), Tuple15<B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> tupled(A)) → Codec<A>

forProduct16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH, Codec<I> codecI, Codec<J> codecJ, Codec<K> codecK, Codec<L> codecL, Codec<M> codecM, Codec<N> codecN, Codec<O> codecO, Codec<P> codecP, Codec<Q> codecQ, A apply(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q), Tuple16<B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> tupled(A)) → Codec<A>

forProduct17<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH, Codec<I> codecI, Codec<J> codecJ, Codec<K> codecK, Codec<L> codecL, Codec<M> codecM, Codec<N> codecN, Codec<O> codecO, Codec<P> codecP, Codec<Q> codecQ, Codec<R> codecR, A apply(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R), Tuple17<B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> tupled(A)) → Codec<A>

forProduct18<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH, Codec<I> codecI, Codec<J> codecJ, Codec<K> codecK, Codec<L> codecL, Codec<M> codecM, Codec<N> codecN, Codec<O> codecO, Codec<P> codecP, Codec<Q> codecQ, Codec<R> codecR, Codec<S> codecS, A apply(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S), Tuple18<B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> tupled(A)) → Codec<A>

forProduct19<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH, Codec<I> codecI, Codec<J> codecJ, Codec<K> codecK, Codec<L> codecL, Codec<M> codecM, Codec<N> codecN, Codec<O> codecO, Codec<P> codecP, Codec<Q> codecQ, Codec<R> codecR, Codec<S> codecS, Codec<T> codecT, A apply(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T), Tuple19<B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> tupled(A)) → Codec<A>

forProduct2<A, B, C>(Codec<B> codecB, Codec<C> codecC, A apply(B, C), Tuple2<B, C> tupled(A)) → Codec<A>

/////////////////////////////////////////////////////////////////////////// /////////////////////////////// ProductN ////////////////////////////////// ///////////////////////////////////////////////////////////////////////////

forProduct20<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH, Codec<I> codecI, Codec<J> codecJ, Codec<K> codecK, Codec<L> codecL, Codec<M> codecM, Codec<N> codecN, Codec<O> codecO, Codec<P> codecP, Codec<Q> codecQ, Codec<R> codecR, Codec<S> codecS, Codec<T> codecT, Codec<U> codecU, A apply(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U), Tuple20<B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> tupled(A)) → Codec<A>

forProduct3<A, B, C, D>(Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, A apply(B, C, D), Tuple3<B, C, D> tupled(A)) → Codec<A>

forProduct4<A, B, C, D, E>(Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, A apply(B, C, D, E), Tuple4<B, C, D, E> tupled(A)) → Codec<A>

forProduct5<A, B, C, D, E, F>(Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, A apply(B, C, D, E, F), Tuple5<B, C, D, E, F> tupled(A)) → Codec<A>

forProduct6<A, B, C, D, E, F, G>(Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, A apply(B, C, D, E, F, G), Tuple6<B, C, D, E, F, G> tupled(A)) → Codec<A>

forProduct7<A, B, C, D, E, F, G, H>(Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH, A apply(B, C, D, E, F, G, H), Tuple7<B, C, D, E, F, G, H> tupled(A)) → Codec<A>

forProduct8<A, B, C, D, E, F, G, H, I>(Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH, Codec<I> codecI, A apply(B, C, D, E, F, G, H, I), Tuple8<B, C, D, E, F, G, H, I> tupled(A)) → Codec<A>

forProduct9<A, B, C, D, E, F, G, H, I, J>(Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH, Codec<I> codecI, Codec<J> codecJ, A apply(B, C, D, E, F, G, H, I, J), Tuple9<B, C, D, E, F, G, H, I, J> tupled(A)) → Codec<A>

ilistOf<A>(Codec<A> elementCodec) → Codec<IList<A>>

listOf<A>(Codec<A> elementCodec) → Codec<List<A>>

tuple10<A, B, C, D, E, F, G, H, I, J>(Codec<A> codecA, Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH, Codec<I> codecI, Codec<J> codecJ) → Codec<Tuple10<A, B, C, D, E, F, G, H, I, J>>

tuple11<A, B, C, D, E, F, G, H, I, J, K>(Codec<A> codecA, Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH, Codec<I> codecI, Codec<J> codecJ, Codec<K> codecK) → Codec<Tuple11<A, B, C, D, E, F, G, H, I, J, K>>

tuple12<A, B, C, D, E, F, G, H, I, J, K, L>(Codec<A> codecA, Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH, Codec<I> codecI, Codec<J> codecJ, Codec<K> codecK, Codec<L> codecL) → Codec<Tuple12<A, B, C, D, E, F, G, H, I, J, K, L>>

tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>(Codec<A> codecA, Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH, Codec<I> codecI, Codec<J> codecJ, Codec<K> codecK, Codec<L> codecL, Codec<M> codecM) → Codec<Tuple13<A, B, C, D, E, F, G, H, I, J, K, L, M>>

tuple14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(Codec<A> codecA, Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH, Codec<I> codecI, Codec<J> codecJ, Codec<K> codecK, Codec<L> codecL, Codec<M> codecM, Codec<N> codecN) → Codec<Tuple14<A, B, C, D, E, F, G, H, I, J, K, L, M, N>>

tuple15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(Codec<A> codecA, Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH, Codec<I> codecI, Codec<J> codecJ, Codec<K> codecK, Codec<L> codecL, Codec<M> codecM, Codec<N> codecN, Codec<O> codecO) → Codec<Tuple15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>>

tuple16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(Codec<A> codecA, Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH, Codec<I> codecI, Codec<J> codecJ, Codec<K> codecK, Codec<L> codecL, Codec<M> codecM, Codec<N> codecN, Codec<O> codecO, Codec<P> codecP) → Codec<Tuple16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>>

tuple17<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(Codec<A> codecA, Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH, Codec<I> codecI, Codec<J> codecJ, Codec<K> codecK, Codec<L> codecL, Codec<M> codecM, Codec<N> codecN, Codec<O> codecO, Codec<P> codecP, Codec<Q> codecQ) → Codec<Tuple17<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>>

tuple18<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(Codec<A> codecA, Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH, Codec<I> codecI, Codec<J> codecJ, Codec<K> codecK, Codec<L> codecL, Codec<M> codecM, Codec<N> codecN, Codec<O> codecO, Codec<P> codecP, Codec<Q> codecQ, Codec<R> codecR) → Codec<Tuple18<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>>

tuple19<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(Codec<A> codecA, Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH, Codec<I> codecI, Codec<J> codecJ, Codec<K> codecK, Codec<L> codecL, Codec<M> codecM, Codec<N> codecN, Codec<O> codecO, Codec<P> codecP, Codec<Q> codecQ, Codec<R> codecR, Codec<S> codecS) → Codec<Tuple19<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>>

tuple2<A, B>(Codec<A> codecA, Codec<B> codecB) → Codec<Tuple2<A, B>>

/////////////////////////////////////////////////////////////////////////// //////////////////////////////// TupleN /////////////////////////////////// ///////////////////////////////////////////////////////////////////////////

tuple20<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(Codec<A> codecA, Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH, Codec<I> codecI, Codec<J> codecJ, Codec<K> codecK, Codec<L> codecL, Codec<M> codecM, Codec<N> codecN, Codec<O> codecO, Codec<P> codecP, Codec<Q> codecQ, Codec<R> codecR, Codec<S> codecS, Codec<T> codecT) → Codec<Tuple20<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>>

tuple3<A, B, C>(Codec<A> codecA, Codec<B> codecB, Codec<C> codecC) → Codec<Tuple3<A, B, C>>

tuple4<A, B, C, D>(Codec<A> codecA, Codec<B> codecB, Codec<C> codecC, Codec<D> codecD) → Codec<Tuple4<A, B, C, D>>

tuple5<A, B, C, D, E>(Codec<A> codecA, Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE) → Codec<Tuple5<A, B, C, D, E>>

tuple6<A, B, C, D, E, F>(Codec<A> codecA, Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF) → Codec<Tuple6<A, B, C, D, E, F>>

tuple7<A, B, C, D, E, F, G>(Codec<A> codecA, Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG) → Codec<Tuple7<A, B, C, D, E, F, G>>

tuple8<A, B, C, D, E, F, G, H>(Codec<A> codecA, Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH) → Codec<Tuple8<A, B, C, D, E, F, G, H>>

tuple9<A, B, C, D, E, F, G, H, I>(Codec<A> codecA, Codec<B> codecB, Codec<C> codecC, Codec<D> codecD, Codec<E> codecE, Codec<F> codecF, Codec<G> codecG, Codec<H> codecH, Codec<I> codecI) → Codec<Tuple9<A, B, C, D, E, F, G, H, I>>