Decoder<A> class

A Decoder provides the ability to convert JSON into values.

Properties

hashCode → int
The hash code for this object.
no setterinherited
key → Option<String>
final
nullable → Decoder<A?>
no setter
optional → Decoder<Option<A>>
no setter
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited

Methods

as<B>(B b) → Decoder<B>
at(String key) → Decoder<A>
/////////////////////////////////////////////////////////////////////////// ///////////////////////////// Combinators ///////////////////////////////// ///////////////////////////////////////////////////////////////////////////
decode(dynamic json) → DecodeResult<A>
either<B>(Decoder<B> decodeB) → Decoder<Either<A, B>>
emap<B>(Either<DecodingError, B> f(A)) → Decoder<B>
ensure(bool predicate(A), String message) → Decoder<A>
flatMap<B>(Decoder<B> decodeB(A)) → Decoder<B>
fold<B>(B onError(DecodingError), B onSuccess(A)) → Decoder<B>
handleError(A onFailure(DecodingError)) → Decoder<A>
handleErrorWith(Decoder<A> onFailure(DecodingError)) → Decoder<A>
map<B>(B f(A)) → Decoder<B>
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
omap<B>(Option<B> f(A), DecodingError onNone()) → Decoder<B>
recover(A a) → Decoder<A>
recoverWith(Decoder<A> other) → Decoder<A>
toString() → String
A string representation of this object.
inherited
withDefault(A a) → Decoder<A>
withErrorMessage(String message) → Decoder<A>

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Properties

bigint ↔ Decoder<BigInt>
/////////////////////////////////////////////////////////////////////////// ////////////////////////////// Primitives ///////////////////////////////// ///////////////////////////////////////////////////////////////////////////
getter/setter pair
boolean ↔ Decoder<bool>
getter/setter pair
dateTime ↔ Decoder<DateTime>
getter/setter pair
dubble ↔ Decoder<double>
getter/setter pair
duration ↔ Decoder<Duration>
getter/setter pair
integer ↔ Decoder<int>
getter/setter pair
number ↔ Decoder<num>
getter/setter pair
object ↔ Decoder<Map<String, dynamic>>
getter/setter pair
string ↔ Decoder<String>
getter/setter pair

Static Methods

error<A>(DecodingError reason) → Decoder<A>
fail<A>(String reason) → Decoder<A>
forProduct10<A, B, C, D, E, F, G, H, I, J, K>(Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH, Decoder<I> decodeI, Decoder<J> decodeJ, Decoder<K> decodeK, A fn(B, C, D, E, F, G, H, I, J, K)) → Decoder<A>
forProduct11<A, B, C, D, E, F, G, H, I, J, K, L>(Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH, Decoder<I> decodeI, Decoder<J> decodeJ, Decoder<K> decodeK, Decoder<L> decodeL, A fn(B, C, D, E, F, G, H, I, J, K, L)) → Decoder<A>
forProduct12<A, B, C, D, E, F, G, H, I, J, K, L, M>(Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH, Decoder<I> decodeI, Decoder<J> decodeJ, Decoder<K> decodeK, Decoder<L> decodeL, Decoder<M> decodeM, A fn(B, C, D, E, F, G, H, I, J, K, L, M)) → Decoder<A>
forProduct13<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH, Decoder<I> decodeI, Decoder<J> decodeJ, Decoder<K> decodeK, Decoder<L> decodeL, Decoder<M> decodeM, Decoder<N> decodeN, A fn(B, C, D, E, F, G, H, I, J, K, L, M, N)) → Decoder<A>
forProduct14<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH, Decoder<I> decodeI, Decoder<J> decodeJ, Decoder<K> decodeK, Decoder<L> decodeL, Decoder<M> decodeM, Decoder<N> decodeN, Decoder<O> decodeO, A fn(B, C, D, E, F, G, H, I, J, K, L, M, N, O)) → Decoder<A>
forProduct15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH, Decoder<I> decodeI, Decoder<J> decodeJ, Decoder<K> decodeK, Decoder<L> decodeL, Decoder<M> decodeM, Decoder<N> decodeN, Decoder<O> decodeO, Decoder<P> decodeP, A fn(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)) → Decoder<A>
forProduct16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH, Decoder<I> decodeI, Decoder<J> decodeJ, Decoder<K> decodeK, Decoder<L> decodeL, Decoder<M> decodeM, Decoder<N> decodeN, Decoder<O> decodeO, Decoder<P> decodeP, Decoder<Q> decodeQ, A fn(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)) → Decoder<A>
forProduct17<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH, Decoder<I> decodeI, Decoder<J> decodeJ, Decoder<K> decodeK, Decoder<L> decodeL, Decoder<M> decodeM, Decoder<N> decodeN, Decoder<O> decodeO, Decoder<P> decodeP, Decoder<Q> decodeQ, Decoder<R> decodeR, A fn(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)) → Decoder<A>
forProduct18<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH, Decoder<I> decodeI, Decoder<J> decodeJ, Decoder<K> decodeK, Decoder<L> decodeL, Decoder<M> decodeM, Decoder<N> decodeN, Decoder<O> decodeO, Decoder<P> decodeP, Decoder<Q> decodeQ, Decoder<R> decodeR, Decoder<S> decodeS, A fn(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)) → Decoder<A>
forProduct19<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH, Decoder<I> decodeI, Decoder<J> decodeJ, Decoder<K> decodeK, Decoder<L> decodeL, Decoder<M> decodeM, Decoder<N> decodeN, Decoder<O> decodeO, Decoder<P> decodeP, Decoder<Q> decodeQ, Decoder<R> decodeR, Decoder<S> decodeS, Decoder<T> decodeT, A fn(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)) → Decoder<A>
forProduct2<A, B, C>(Decoder<B> decodeB, Decoder<C> decodeC, A fn(B, C)) → Decoder<A>
/////////////////////////////////////////////////////////////////////////// /////////////////////////////// ProductN ////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
forProduct20<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH, Decoder<I> decodeI, Decoder<J> decodeJ, Decoder<K> decodeK, Decoder<L> decodeL, Decoder<M> decodeM, Decoder<N> decodeN, Decoder<O> decodeO, Decoder<P> decodeP, Decoder<Q> decodeQ, Decoder<R> decodeR, Decoder<S> decodeS, Decoder<T> decodeT, Decoder<U> decodeU, A fn(B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)) → Decoder<A>
forProduct3<A, B, C, D>(Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, A fn(B, C, D)) → Decoder<A>
forProduct4<A, B, C, D, E>(Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, A fn(B, C, D, E)) → Decoder<A>
forProduct5<A, B, C, D, E, F>(Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, A fn(B, C, D, E, F)) → Decoder<A>
forProduct6<A, B, C, D, E, F, G>(Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, A fn(B, C, D, E, F, G)) → Decoder<A>
forProduct7<A, B, C, D, E, F, G, H>(Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH, A fn(B, C, D, E, F, G, H)) → Decoder<A>
forProduct8<A, B, C, D, E, F, G, H, I>(Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH, Decoder<I> decodeI, A fn(B, C, D, E, F, G, H, I)) → Decoder<A>
forProduct9<A, B, C, D, E, F, G, H, I, J>(Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH, Decoder<I> decodeI, Decoder<J> decodeJ, A fn(B, C, D, E, F, G, H, I, J)) → Decoder<A>
ilistOf<A>(Decoder<A> elementDecoder) → Decoder<IList<A>>
lift<A>(DecodeResult<A> result) → Decoder<A>
listOf<A>(Decoder<A> elementDecoder) → Decoder<List<A>>
pure<A>(A value) → Decoder<A>
tuple10<A, B, C, D, E, F, G, H, I, J>(Decoder<A> decodeA, Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH, Decoder<I> decodeI, Decoder<J> decodeJ) → Decoder<Tuple10<A, B, C, D, E, F, G, H, I, J>>
tuple11<A, B, C, D, E, F, G, H, I, J, K>(Decoder<A> decodeA, Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH, Decoder<I> decodeI, Decoder<J> decodeJ, Decoder<K> decodeK) → Decoder<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>(Decoder<A> decodeA, Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH, Decoder<I> decodeI, Decoder<J> decodeJ, Decoder<K> decodeK, Decoder<L> decodeL) → Decoder<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>(Decoder<A> decodeA, Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH, Decoder<I> decodeI, Decoder<J> decodeJ, Decoder<K> decodeK, Decoder<L> decodeL, Decoder<M> decodeM) → Decoder<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>(Decoder<A> decodeA, Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH, Decoder<I> decodeI, Decoder<J> decodeJ, Decoder<K> decodeK, Decoder<L> decodeL, Decoder<M> decodeM, Decoder<N> decodeN) → Decoder<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>(Decoder<A> decodeA, Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH, Decoder<I> decodeI, Decoder<J> decodeJ, Decoder<K> decodeK, Decoder<L> decodeL, Decoder<M> decodeM, Decoder<N> decodeN, Decoder<O> decodeO) → Decoder<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>(Decoder<A> decodeA, Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH, Decoder<I> decodeI, Decoder<J> decodeJ, Decoder<K> decodeK, Decoder<L> decodeL, Decoder<M> decodeM, Decoder<N> decodeN, Decoder<O> decodeO, Decoder<P> decodeP) → Decoder<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>(Decoder<A> decodeA, Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH, Decoder<I> decodeI, Decoder<J> decodeJ, Decoder<K> decodeK, Decoder<L> decodeL, Decoder<M> decodeM, Decoder<N> decodeN, Decoder<O> decodeO, Decoder<P> decodeP, Decoder<Q> decodeQ) → Decoder<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>(Decoder<A> decodeA, Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH, Decoder<I> decodeI, Decoder<J> decodeJ, Decoder<K> decodeK, Decoder<L> decodeL, Decoder<M> decodeM, Decoder<N> decodeN, Decoder<O> decodeO, Decoder<P> decodeP, Decoder<Q> decodeQ, Decoder<R> decodeR) → Decoder<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>(Decoder<A> decodeA, Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH, Decoder<I> decodeI, Decoder<J> decodeJ, Decoder<K> decodeK, Decoder<L> decodeL, Decoder<M> decodeM, Decoder<N> decodeN, Decoder<O> decodeO, Decoder<P> decodeP, Decoder<Q> decodeQ, Decoder<R> decodeR, Decoder<S> decodeS) → Decoder<Tuple19<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>>
tuple2<A, B>(Decoder<A> decodeA, Decoder<B> decodeB) → Decoder<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>(Decoder<A> decodeA, Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH, Decoder<I> decodeI, Decoder<J> decodeJ, Decoder<K> decodeK, Decoder<L> decodeL, Decoder<M> decodeM, Decoder<N> decodeN, Decoder<O> decodeO, Decoder<P> decodeP, Decoder<Q> decodeQ, Decoder<R> decodeR, Decoder<S> decodeS, Decoder<T> decodeT) → Decoder<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>(Decoder<A> decodeA, Decoder<B> decodeB, Decoder<C> decodeC) → Decoder<Tuple3<A, B, C>>
tuple4<A, B, C, D>(Decoder<A> decodeA, Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD) → Decoder<Tuple4<A, B, C, D>>
tuple5<A, B, C, D, E>(Decoder<A> decodeA, Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE) → Decoder<Tuple5<A, B, C, D, E>>
tuple6<A, B, C, D, E, F>(Decoder<A> decodeA, Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF) → Decoder<Tuple6<A, B, C, D, E, F>>
tuple7<A, B, C, D, E, F, G>(Decoder<A> decodeA, Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG) → Decoder<Tuple7<A, B, C, D, E, F, G>>
tuple8<A, B, C, D, E, F, G, H>(Decoder<A> decodeA, Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH) → Decoder<Tuple8<A, B, C, D, E, F, G, H>>
tuple9<A, B, C, D, E, F, G, H, I>(Decoder<A> decodeA, Decoder<B> decodeB, Decoder<C> decodeC, Decoder<D> decodeD, Decoder<E> decodeE, Decoder<F> decodeF, Decoder<G> decodeG, Decoder<H> decodeH, Decoder<I> decodeI) → Decoder<Tuple9<A, B, C, D, E, F, G, H, I>>