Encoder<A> class

An Encoder provides the ability to convert from a type to JSON.

Constructors

Encoder.custom(dynamic _encodeF(A))

const

Properties

hashCode → int

The hash code for this object.

no setter, inherited

key → Option<String>

final

nullable → Encoder<A?>

no setter

optional → Encoder<Option<A>>

no setter

runtimeType → Type

A representation of the runtime type of the object.

no setter, inherited

Methods

at(String key) → Encoder<A>

/////////////////////////////////////////////////////////////////////////// ///////////////////////////// Combinators ///////////////////////////////// ///////////////////////////////////////////////////////////////////////////

contramap<B>(A f(B)) → Encoder<B>

either<B>(Encoder<B> encodeB) → Encoder<Either<A, B>>

encode(A a) → dynamic

noSuchMethod(Invocation invocation) → dynamic

Invoked when a nonexistent method or property is accessed.

inherited

toString() → String

A string representation of this object.

inherited

Operators

operator ==(Object other) → bool

The equality operator.

inherited

Static Properties

bigint ↔ Encoder<BigInt>

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

getter/setter pair

boolean ↔ Encoder<bool>

getter/setter pair

dateTime ↔ Encoder<DateTime>

getter/setter pair

dubble ↔ Encoder<double>

getter/setter pair

duration ↔ Encoder<Duration>

getter/setter pair

integer ↔ Encoder<int>

getter/setter pair

number ↔ Encoder<num>

getter/setter pair

object ↔ Encoder<Map<String, dynamic>>

getter/setter pair

string ↔ Encoder<String>

getter/setter pair

Static Methods

forProduct10<A, B, C, D, E, F, G, H, I, J, K>(Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH, Encoder<I> encodeI, Encoder<J> encodeJ, Encoder<K> encodeK, Tuple10<B, C, D, E, F, G, H, I, J, K> fn(A)) → Encoder<A>

forProduct11<A, B, C, D, E, F, G, H, I, J, K, L>(Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH, Encoder<I> encodeI, Encoder<J> encodeJ, Encoder<K> encodeK, Encoder<L> encodeL, Tuple11<B, C, D, E, F, G, H, I, J, K, L> fn(A)) → Encoder<A>

forProduct12<A, B, C, D, E, F, G, H, I, J, K, L, M>(Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH, Encoder<I> encodeI, Encoder<J> encodeJ, Encoder<K> encodeK, Encoder<L> encodeL, Encoder<M> encodeM, Tuple12<B, C, D, E, F, G, H, I, J, K, L, M> fn(A)) → Encoder<A>

forProduct13<A, B, C, D, E, F, G, H, I, J, K, L, M, N>(Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH, Encoder<I> encodeI, Encoder<J> encodeJ, Encoder<K> encodeK, Encoder<L> encodeL, Encoder<M> encodeM, Encoder<N> encodeN, Tuple13<B, C, D, E, F, G, H, I, J, K, L, M, N> fn(A)) → Encoder<A>

forProduct14<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O>(Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH, Encoder<I> encodeI, Encoder<J> encodeJ, Encoder<K> encodeK, Encoder<L> encodeL, Encoder<M> encodeM, Encoder<N> encodeN, Encoder<O> encodeO, Tuple14<B, C, D, E, F, G, H, I, J, K, L, M, N, O> fn(A)) → Encoder<A>

forProduct15<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH, Encoder<I> encodeI, Encoder<J> encodeJ, Encoder<K> encodeK, Encoder<L> encodeL, Encoder<M> encodeM, Encoder<N> encodeN, Encoder<O> encodeO, Encoder<P> encodeP, Tuple15<B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> fn(A)) → Encoder<A>

forProduct16<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q>(Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH, Encoder<I> encodeI, Encoder<J> encodeJ, Encoder<K> encodeK, Encoder<L> encodeL, Encoder<M> encodeM, Encoder<N> encodeN, Encoder<O> encodeO, Encoder<P> encodeP, Encoder<Q> encodeQ, Tuple16<B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> fn(A)) → Encoder<A>

forProduct17<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R>(Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH, Encoder<I> encodeI, Encoder<J> encodeJ, Encoder<K> encodeK, Encoder<L> encodeL, Encoder<M> encodeM, Encoder<N> encodeN, Encoder<O> encodeO, Encoder<P> encodeP, Encoder<Q> encodeQ, Encoder<R> encodeR, Tuple17<B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> fn(A)) → Encoder<A>

forProduct18<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>(Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH, Encoder<I> encodeI, Encoder<J> encodeJ, Encoder<K> encodeK, Encoder<L> encodeL, Encoder<M> encodeM, Encoder<N> encodeN, Encoder<O> encodeO, Encoder<P> encodeP, Encoder<Q> encodeQ, Encoder<R> encodeR, Encoder<S> encodeS, Tuple18<B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> fn(A)) → Encoder<A>

forProduct19<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T>(Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH, Encoder<I> encodeI, Encoder<J> encodeJ, Encoder<K> encodeK, Encoder<L> encodeL, Encoder<M> encodeM, Encoder<N> encodeN, Encoder<O> encodeO, Encoder<P> encodeP, Encoder<Q> encodeQ, Encoder<R> encodeR, Encoder<S> encodeS, Encoder<T> encodeT, Tuple19<B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> fn(A)) → Encoder<A>

forProduct2<A, B, C>(Encoder<B> encodeB, Encoder<C> encodeC, Tuple2<B, C> fn(A)) → Encoder<A>

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

forProduct20<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U>(Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH, Encoder<I> encodeI, Encoder<J> encodeJ, Encoder<K> encodeK, Encoder<L> encodeL, Encoder<M> encodeM, Encoder<N> encodeN, Encoder<O> encodeO, Encoder<P> encodeP, Encoder<Q> encodeQ, Encoder<R> encodeR, Encoder<S> encodeS, Encoder<T> encodeT, Encoder<U> encodeU, Tuple20<B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> fn(A)) → Encoder<A>

forProduct3<A, B, C, D>(Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Tuple3<B, C, D> fn(A)) → Encoder<A>

forProduct4<A, B, C, D, E>(Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Tuple4<B, C, D, E> fn(A)) → Encoder<A>

forProduct5<A, B, C, D, E, F>(Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Tuple5<B, C, D, E, F> fn(A)) → Encoder<A>

forProduct6<A, B, C, D, E, F, G>(Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Tuple6<B, C, D, E, F, G> fn(A)) → Encoder<A>

forProduct7<A, B, C, D, E, F, G, H>(Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH, Tuple7<B, C, D, E, F, G, H> fn(A)) → Encoder<A>

forProduct8<A, B, C, D, E, F, G, H, I>(Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH, Encoder<I> encodeI, Tuple8<B, C, D, E, F, G, H, I> fn(A)) → Encoder<A>

forProduct9<A, B, C, D, E, F, G, H, I, J>(Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH, Encoder<I> encodeI, Encoder<J> encodeJ, Tuple9<B, C, D, E, F, G, H, I, J> fn(A)) → Encoder<A>

ilistOf<A>(Encoder<A> elementEncoder) → Encoder<IList<A>>

listOf<A>(Encoder<A> elementEncoder) → Encoder<List<A>>

tuple10<A, B, C, D, E, F, G, H, I, J>(Encoder<A> encodeA, Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH, Encoder<I> encodeI, Encoder<J> encodeJ) → Encoder<Tuple10<A, B, C, D, E, F, G, H, I, J>>

tuple11<A, B, C, D, E, F, G, H, I, J, K>(Encoder<A> encodeA, Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH, Encoder<I> encodeI, Encoder<J> encodeJ, Encoder<K> encodeK) → Encoder<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>(Encoder<A> encodeA, Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH, Encoder<I> encodeI, Encoder<J> encodeJ, Encoder<K> encodeK, Encoder<L> encodeL) → Encoder<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>(Encoder<A> encodeA, Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH, Encoder<I> encodeI, Encoder<J> encodeJ, Encoder<K> encodeK, Encoder<L> encodeL, Encoder<M> encodeM) → Encoder<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>(Encoder<A> encodeA, Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH, Encoder<I> encodeI, Encoder<J> encodeJ, Encoder<K> encodeK, Encoder<L> encodeL, Encoder<M> encodeM, Encoder<N> encodeN) → Encoder<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>(Encoder<A> encodeA, Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH, Encoder<I> encodeI, Encoder<J> encodeJ, Encoder<K> encodeK, Encoder<L> encodeL, Encoder<M> encodeM, Encoder<N> encodeN, Encoder<O> encodeO) → Encoder<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>(Encoder<A> encodeA, Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH, Encoder<I> encodeI, Encoder<J> encodeJ, Encoder<K> encodeK, Encoder<L> encodeL, Encoder<M> encodeM, Encoder<N> encodeN, Encoder<O> encodeO, Encoder<P> encodeP) → Encoder<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>(Encoder<A> encodeA, Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH, Encoder<I> encodeI, Encoder<J> encodeJ, Encoder<K> encodeK, Encoder<L> encodeL, Encoder<M> encodeM, Encoder<N> encodeN, Encoder<O> encodeO, Encoder<P> encodeP, Encoder<Q> encodeQ) → Encoder<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>(Encoder<A> encodeA, Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH, Encoder<I> encodeI, Encoder<J> encodeJ, Encoder<K> encodeK, Encoder<L> encodeL, Encoder<M> encodeM, Encoder<N> encodeN, Encoder<O> encodeO, Encoder<P> encodeP, Encoder<Q> encodeQ, Encoder<R> encodeR) → Encoder<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>(Encoder<A> encodeA, Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH, Encoder<I> encodeI, Encoder<J> encodeJ, Encoder<K> encodeK, Encoder<L> encodeL, Encoder<M> encodeM, Encoder<N> encodeN, Encoder<O> encodeO, Encoder<P> encodeP, Encoder<Q> encodeQ, Encoder<R> encodeR, Encoder<S> encodeS) → Encoder<Tuple19<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S>>

tuple2<A, B>(Encoder<A> encodeA, Encoder<B> encodeB) → Encoder<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>(Encoder<A> encodeA, Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH, Encoder<I> encodeI, Encoder<J> encodeJ, Encoder<K> encodeK, Encoder<L> encodeL, Encoder<M> encodeM, Encoder<N> encodeN, Encoder<O> encodeO, Encoder<P> encodeP, Encoder<Q> encodeQ, Encoder<R> encodeR, Encoder<S> encodeS, Encoder<T> encodeT) → Encoder<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>(Encoder<A> encodeA, Encoder<B> encodeB, Encoder<C> encodeC) → Encoder<Tuple3<A, B, C>>

tuple4<A, B, C, D>(Encoder<A> encodeA, Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD) → Encoder<Tuple4<A, B, C, D>>

tuple5<A, B, C, D, E>(Encoder<A> encodeA, Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE) → Encoder<Tuple5<A, B, C, D, E>>

tuple6<A, B, C, D, E, F>(Encoder<A> encodeA, Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF) → Encoder<Tuple6<A, B, C, D, E, F>>

tuple7<A, B, C, D, E, F, G>(Encoder<A> encodeA, Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG) → Encoder<Tuple7<A, B, C, D, E, F, G>>

tuple8<A, B, C, D, E, F, G, H>(Encoder<A> encodeA, Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH) → Encoder<Tuple8<A, B, C, D, E, F, G, H>>

tuple9<A, B, C, D, E, F, G, H, I>(Encoder<A> encodeA, Encoder<B> encodeB, Encoder<C> encodeC, Encoder<D> encodeD, Encoder<E> encodeE, Encoder<F> encodeF, Encoder<G> encodeG, Encoder<H> encodeH, Encoder<I> encodeI) → Encoder<Tuple9<A, B, C, D, E, F, G, H, I>>