Trait EncoderFor

pub trait EncoderFor<F>
where
    F: 'static,
{
    // Required method
    fn encode_for(&self, buf: &mut BufWriter<'_>);
}

Marks a type as an encoder for a given type.

Required Methods

fn encode_for(&self, buf: &mut BufWriter<'_>)

Implementations on Foreign Types

impl EncoderFor<f32> for f32

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl EncoderFor<f64> for f64

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl EncoderFor<i8> for i8

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl EncoderFor<i16> for i16

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl EncoderFor<i32> for i32

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl EncoderFor<i64> for i64

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl EncoderFor<i128> for i128

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl EncoderFor<u8> for u8

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl EncoderFor<u16> for u16

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl EncoderFor<u32> for u32

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl EncoderFor<u64> for u64

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl EncoderFor<u128> for u128

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl EncoderFor<Length> for u32

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<A, AX, B, BX, C, CX, D, DX, E, EX, F, FX, G, GX, H, HX, I, IX, J, JX, K, KX, L, LX, M, MX, N, NX, O, OX, P, PX, Q, QX, R, RX, S, SX, T, TX, U, UX, V, VX, W, WX, X, XX, Y, YX, Z, ZX, A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(AX, BX, CX, DX, EX, FX, GX, HX, IX, JX, KX, LX, MX, NX, OX, PX, QX, RX, SX, TX, UX, VX, WX, XX, YX, ZX, A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where AX: 'static, BX: 'static, CX: 'static, DX: 'static, EX: 'static, FX: 'static, GX: 'static, HX: 'static, IX: 'static, JX: 'static, KX: 'static, LX: 'static, MX: 'static, NX: 'static, OX: 'static, PX: 'static, QX: 'static, RX: 'static, SX: 'static, TX: 'static, UX: 'static, VX: 'static, WX: 'static, XX: 'static, YX: 'static, ZX: 'static, A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, A: EncoderFor<AX>, B: EncoderFor<BX>, C: EncoderFor<CX>, D: EncoderFor<DX>, E: EncoderFor<EX>, F: EncoderFor<FX>, G: EncoderFor<GX>, H: EncoderFor<HX>, I: EncoderFor<IX>, J: EncoderFor<JX>, K: EncoderFor<KX>, L: EncoderFor<LX>, M: EncoderFor<MX>, N: EncoderFor<NX>, O: EncoderFor<OX>, P: EncoderFor<PX>, Q: EncoderFor<QX>, R: EncoderFor<RX>, S: EncoderFor<SX>, T: EncoderFor<TX>, U: EncoderFor<UX>, V: EncoderFor<VX>, W: EncoderFor<WX>, X: EncoderFor<XX>, Y: EncoderFor<YX>, Z: EncoderFor<ZX>, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<B, BX, C, CX, D, DX, E, EX, F, FX, G, GX, H, HX, I, IX, J, JX, K, KX, L, LX, M, MX, N, NX, O, OX, P, PX, Q, QX, R, RX, S, SX, T, TX, U, UX, V, VX, W, WX, X, XX, Y, YX, Z, ZX, A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(BX, CX, DX, EX, FX, GX, HX, IX, JX, KX, LX, MX, NX, OX, PX, QX, RX, SX, TX, UX, VX, WX, XX, YX, ZX, A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where BX: 'static, CX: 'static, DX: 'static, EX: 'static, FX: 'static, GX: 'static, HX: 'static, IX: 'static, JX: 'static, KX: 'static, LX: 'static, MX: 'static, NX: 'static, OX: 'static, PX: 'static, QX: 'static, RX: 'static, SX: 'static, TX: 'static, UX: 'static, VX: 'static, WX: 'static, XX: 'static, YX: 'static, ZX: 'static, A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, B: EncoderFor<BX>, C: EncoderFor<CX>, D: EncoderFor<DX>, E: EncoderFor<EX>, F: EncoderFor<FX>, G: EncoderFor<GX>, H: EncoderFor<HX>, I: EncoderFor<IX>, J: EncoderFor<JX>, K: EncoderFor<KX>, L: EncoderFor<LX>, M: EncoderFor<MX>, N: EncoderFor<NX>, O: EncoderFor<OX>, P: EncoderFor<PX>, Q: EncoderFor<QX>, R: EncoderFor<RX>, S: EncoderFor<SX>, T: EncoderFor<TX>, U: EncoderFor<UX>, V: EncoderFor<VX>, W: EncoderFor<WX>, X: EncoderFor<XX>, Y: EncoderFor<YX>, Z: EncoderFor<ZX>, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<C, CX, D, DX, E, EX, F, FX, G, GX, H, HX, I, IX, J, JX, K, KX, L, LX, M, MX, N, NX, O, OX, P, PX, Q, QX, R, RX, S, SX, T, TX, U, UX, V, VX, W, WX, X, XX, Y, YX, Z, ZX, A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(CX, DX, EX, FX, GX, HX, IX, JX, KX, LX, MX, NX, OX, PX, QX, RX, SX, TX, UX, VX, WX, XX, YX, ZX, A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where CX: 'static, DX: 'static, EX: 'static, FX: 'static, GX: 'static, HX: 'static, IX: 'static, JX: 'static, KX: 'static, LX: 'static, MX: 'static, NX: 'static, OX: 'static, PX: 'static, QX: 'static, RX: 'static, SX: 'static, TX: 'static, UX: 'static, VX: 'static, WX: 'static, XX: 'static, YX: 'static, ZX: 'static, A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, C: EncoderFor<CX>, D: EncoderFor<DX>, E: EncoderFor<EX>, F: EncoderFor<FX>, G: EncoderFor<GX>, H: EncoderFor<HX>, I: EncoderFor<IX>, J: EncoderFor<JX>, K: EncoderFor<KX>, L: EncoderFor<LX>, M: EncoderFor<MX>, N: EncoderFor<NX>, O: EncoderFor<OX>, P: EncoderFor<PX>, Q: EncoderFor<QX>, R: EncoderFor<RX>, S: EncoderFor<SX>, T: EncoderFor<TX>, U: EncoderFor<UX>, V: EncoderFor<VX>, W: EncoderFor<WX>, X: EncoderFor<XX>, Y: EncoderFor<YX>, Z: EncoderFor<ZX>, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<D, DX, E, EX, F, FX, G, GX, H, HX, I, IX, J, JX, K, KX, L, LX, M, MX, N, NX, O, OX, P, PX, Q, QX, R, RX, S, SX, T, TX, U, UX, V, VX, W, WX, X, XX, Y, YX, Z, ZX, A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(DX, EX, FX, GX, HX, IX, JX, KX, LX, MX, NX, OX, PX, QX, RX, SX, TX, UX, VX, WX, XX, YX, ZX, A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where DX: 'static, EX: 'static, FX: 'static, GX: 'static, HX: 'static, IX: 'static, JX: 'static, KX: 'static, LX: 'static, MX: 'static, NX: 'static, OX: 'static, PX: 'static, QX: 'static, RX: 'static, SX: 'static, TX: 'static, UX: 'static, VX: 'static, WX: 'static, XX: 'static, YX: 'static, ZX: 'static, A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, D: EncoderFor<DX>, E: EncoderFor<EX>, F: EncoderFor<FX>, G: EncoderFor<GX>, H: EncoderFor<HX>, I: EncoderFor<IX>, J: EncoderFor<JX>, K: EncoderFor<KX>, L: EncoderFor<LX>, M: EncoderFor<MX>, N: EncoderFor<NX>, O: EncoderFor<OX>, P: EncoderFor<PX>, Q: EncoderFor<QX>, R: EncoderFor<RX>, S: EncoderFor<SX>, T: EncoderFor<TX>, U: EncoderFor<UX>, V: EncoderFor<VX>, W: EncoderFor<WX>, X: EncoderFor<XX>, Y: EncoderFor<YX>, Z: EncoderFor<ZX>, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<E, EX, F, FX, G, GX, H, HX, I, IX, J, JX, K, KX, L, LX, M, MX, N, NX, O, OX, P, PX, Q, QX, R, RX, S, SX, T, TX, U, UX, V, VX, W, WX, X, XX, Y, YX, Z, ZX, A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(EX, FX, GX, HX, IX, JX, KX, LX, MX, NX, OX, PX, QX, RX, SX, TX, UX, VX, WX, XX, YX, ZX, A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where EX: 'static, FX: 'static, GX: 'static, HX: 'static, IX: 'static, JX: 'static, KX: 'static, LX: 'static, MX: 'static, NX: 'static, OX: 'static, PX: 'static, QX: 'static, RX: 'static, SX: 'static, TX: 'static, UX: 'static, VX: 'static, WX: 'static, XX: 'static, YX: 'static, ZX: 'static, A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, E: EncoderFor<EX>, F: EncoderFor<FX>, G: EncoderFor<GX>, H: EncoderFor<HX>, I: EncoderFor<IX>, J: EncoderFor<JX>, K: EncoderFor<KX>, L: EncoderFor<LX>, M: EncoderFor<MX>, N: EncoderFor<NX>, O: EncoderFor<OX>, P: EncoderFor<PX>, Q: EncoderFor<QX>, R: EncoderFor<RX>, S: EncoderFor<SX>, T: EncoderFor<TX>, U: EncoderFor<UX>, V: EncoderFor<VX>, W: EncoderFor<WX>, X: EncoderFor<XX>, Y: EncoderFor<YX>, Z: EncoderFor<ZX>, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<F, FX, G, GX, H, HX, I, IX, J, JX, K, KX, L, LX, M, MX, N, NX, O, OX, P, PX, Q, QX, R, RX, S, SX, T, TX, U, UX, V, VX, W, WX, X, XX, Y, YX, Z, ZX, A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(FX, GX, HX, IX, JX, KX, LX, MX, NX, OX, PX, QX, RX, SX, TX, UX, VX, WX, XX, YX, ZX, A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where FX: 'static, GX: 'static, HX: 'static, IX: 'static, JX: 'static, KX: 'static, LX: 'static, MX: 'static, NX: 'static, OX: 'static, PX: 'static, QX: 'static, RX: 'static, SX: 'static, TX: 'static, UX: 'static, VX: 'static, WX: 'static, XX: 'static, YX: 'static, ZX: 'static, A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, F: EncoderFor<FX>, G: EncoderFor<GX>, H: EncoderFor<HX>, I: EncoderFor<IX>, J: EncoderFor<JX>, K: EncoderFor<KX>, L: EncoderFor<LX>, M: EncoderFor<MX>, N: EncoderFor<NX>, O: EncoderFor<OX>, P: EncoderFor<PX>, Q: EncoderFor<QX>, R: EncoderFor<RX>, S: EncoderFor<SX>, T: EncoderFor<TX>, U: EncoderFor<UX>, V: EncoderFor<VX>, W: EncoderFor<WX>, X: EncoderFor<XX>, Y: EncoderFor<YX>, Z: EncoderFor<ZX>, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<G, GX, H, HX, I, IX, J, JX, K, KX, L, LX, M, MX, N, NX, O, OX, P, PX, Q, QX, R, RX, S, SX, T, TX, U, UX, V, VX, W, WX, X, XX, Y, YX, Z, ZX, A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(GX, HX, IX, JX, KX, LX, MX, NX, OX, PX, QX, RX, SX, TX, UX, VX, WX, XX, YX, ZX, A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where GX: 'static, HX: 'static, IX: 'static, JX: 'static, KX: 'static, LX: 'static, MX: 'static, NX: 'static, OX: 'static, PX: 'static, QX: 'static, RX: 'static, SX: 'static, TX: 'static, UX: 'static, VX: 'static, WX: 'static, XX: 'static, YX: 'static, ZX: 'static, A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, G: EncoderFor<GX>, H: EncoderFor<HX>, I: EncoderFor<IX>, J: EncoderFor<JX>, K: EncoderFor<KX>, L: EncoderFor<LX>, M: EncoderFor<MX>, N: EncoderFor<NX>, O: EncoderFor<OX>, P: EncoderFor<PX>, Q: EncoderFor<QX>, R: EncoderFor<RX>, S: EncoderFor<SX>, T: EncoderFor<TX>, U: EncoderFor<UX>, V: EncoderFor<VX>, W: EncoderFor<WX>, X: EncoderFor<XX>, Y: EncoderFor<YX>, Z: EncoderFor<ZX>, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<H, HX, I, IX, J, JX, K, KX, L, LX, M, MX, N, NX, O, OX, P, PX, Q, QX, R, RX, S, SX, T, TX, U, UX, V, VX, W, WX, X, XX, Y, YX, Z, ZX, A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(HX, IX, JX, KX, LX, MX, NX, OX, PX, QX, RX, SX, TX, UX, VX, WX, XX, YX, ZX, A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where HX: 'static, IX: 'static, JX: 'static, KX: 'static, LX: 'static, MX: 'static, NX: 'static, OX: 'static, PX: 'static, QX: 'static, RX: 'static, SX: 'static, TX: 'static, UX: 'static, VX: 'static, WX: 'static, XX: 'static, YX: 'static, ZX: 'static, A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, H: EncoderFor<HX>, I: EncoderFor<IX>, J: EncoderFor<JX>, K: EncoderFor<KX>, L: EncoderFor<LX>, M: EncoderFor<MX>, N: EncoderFor<NX>, O: EncoderFor<OX>, P: EncoderFor<PX>, Q: EncoderFor<QX>, R: EncoderFor<RX>, S: EncoderFor<SX>, T: EncoderFor<TX>, U: EncoderFor<UX>, V: EncoderFor<VX>, W: EncoderFor<WX>, X: EncoderFor<XX>, Y: EncoderFor<YX>, Z: EncoderFor<ZX>, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<I, IX, J, JX, K, KX, L, LX, M, MX, N, NX, O, OX, P, PX, Q, QX, R, RX, S, SX, T, TX, U, UX, V, VX, W, WX, X, XX, Y, YX, Z, ZX, A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(IX, JX, KX, LX, MX, NX, OX, PX, QX, RX, SX, TX, UX, VX, WX, XX, YX, ZX, A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where IX: 'static, JX: 'static, KX: 'static, LX: 'static, MX: 'static, NX: 'static, OX: 'static, PX: 'static, QX: 'static, RX: 'static, SX: 'static, TX: 'static, UX: 'static, VX: 'static, WX: 'static, XX: 'static, YX: 'static, ZX: 'static, A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, I: EncoderFor<IX>, J: EncoderFor<JX>, K: EncoderFor<KX>, L: EncoderFor<LX>, M: EncoderFor<MX>, N: EncoderFor<NX>, O: EncoderFor<OX>, P: EncoderFor<PX>, Q: EncoderFor<QX>, R: EncoderFor<RX>, S: EncoderFor<SX>, T: EncoderFor<TX>, U: EncoderFor<UX>, V: EncoderFor<VX>, W: EncoderFor<WX>, X: EncoderFor<XX>, Y: EncoderFor<YX>, Z: EncoderFor<ZX>, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<J, JX, K, KX, L, LX, M, MX, N, NX, O, OX, P, PX, Q, QX, R, RX, S, SX, T, TX, U, UX, V, VX, W, WX, X, XX, Y, YX, Z, ZX, A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(JX, KX, LX, MX, NX, OX, PX, QX, RX, SX, TX, UX, VX, WX, XX, YX, ZX, A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where JX: 'static, KX: 'static, LX: 'static, MX: 'static, NX: 'static, OX: 'static, PX: 'static, QX: 'static, RX: 'static, SX: 'static, TX: 'static, UX: 'static, VX: 'static, WX: 'static, XX: 'static, YX: 'static, ZX: 'static, A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, J: EncoderFor<JX>, K: EncoderFor<KX>, L: EncoderFor<LX>, M: EncoderFor<MX>, N: EncoderFor<NX>, O: EncoderFor<OX>, P: EncoderFor<PX>, Q: EncoderFor<QX>, R: EncoderFor<RX>, S: EncoderFor<SX>, T: EncoderFor<TX>, U: EncoderFor<UX>, V: EncoderFor<VX>, W: EncoderFor<WX>, X: EncoderFor<XX>, Y: EncoderFor<YX>, Z: EncoderFor<ZX>, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<K, KX, L, LX, M, MX, N, NX, O, OX, P, PX, Q, QX, R, RX, S, SX, T, TX, U, UX, V, VX, W, WX, X, XX, Y, YX, Z, ZX, A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(KX, LX, MX, NX, OX, PX, QX, RX, SX, TX, UX, VX, WX, XX, YX, ZX, A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where KX: 'static, LX: 'static, MX: 'static, NX: 'static, OX: 'static, PX: 'static, QX: 'static, RX: 'static, SX: 'static, TX: 'static, UX: 'static, VX: 'static, WX: 'static, XX: 'static, YX: 'static, ZX: 'static, A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, K: EncoderFor<KX>, L: EncoderFor<LX>, M: EncoderFor<MX>, N: EncoderFor<NX>, O: EncoderFor<OX>, P: EncoderFor<PX>, Q: EncoderFor<QX>, R: EncoderFor<RX>, S: EncoderFor<SX>, T: EncoderFor<TX>, U: EncoderFor<UX>, V: EncoderFor<VX>, W: EncoderFor<WX>, X: EncoderFor<XX>, Y: EncoderFor<YX>, Z: EncoderFor<ZX>, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<L, LX, M, MX, N, NX, O, OX, P, PX, Q, QX, R, RX, S, SX, T, TX, U, UX, V, VX, W, WX, X, XX, Y, YX, Z, ZX, A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(LX, MX, NX, OX, PX, QX, RX, SX, TX, UX, VX, WX, XX, YX, ZX, A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where LX: 'static, MX: 'static, NX: 'static, OX: 'static, PX: 'static, QX: 'static, RX: 'static, SX: 'static, TX: 'static, UX: 'static, VX: 'static, WX: 'static, XX: 'static, YX: 'static, ZX: 'static, A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, L: EncoderFor<LX>, M: EncoderFor<MX>, N: EncoderFor<NX>, O: EncoderFor<OX>, P: EncoderFor<PX>, Q: EncoderFor<QX>, R: EncoderFor<RX>, S: EncoderFor<SX>, T: EncoderFor<TX>, U: EncoderFor<UX>, V: EncoderFor<VX>, W: EncoderFor<WX>, X: EncoderFor<XX>, Y: EncoderFor<YX>, Z: EncoderFor<ZX>, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<M, MX, N, NX, O, OX, P, PX, Q, QX, R, RX, S, SX, T, TX, U, UX, V, VX, W, WX, X, XX, Y, YX, Z, ZX, A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(MX, NX, OX, PX, QX, RX, SX, TX, UX, VX, WX, XX, YX, ZX, A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where MX: 'static, NX: 'static, OX: 'static, PX: 'static, QX: 'static, RX: 'static, SX: 'static, TX: 'static, UX: 'static, VX: 'static, WX: 'static, XX: 'static, YX: 'static, ZX: 'static, A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, M: EncoderFor<MX>, N: EncoderFor<NX>, O: EncoderFor<OX>, P: EncoderFor<PX>, Q: EncoderFor<QX>, R: EncoderFor<RX>, S: EncoderFor<SX>, T: EncoderFor<TX>, U: EncoderFor<UX>, V: EncoderFor<VX>, W: EncoderFor<WX>, X: EncoderFor<XX>, Y: EncoderFor<YX>, Z: EncoderFor<ZX>, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<N, NX, O, OX, P, PX, Q, QX, R, RX, S, SX, T, TX, U, UX, V, VX, W, WX, X, XX, Y, YX, Z, ZX, A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(NX, OX, PX, QX, RX, SX, TX, UX, VX, WX, XX, YX, ZX, A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (N, O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where NX: 'static, OX: 'static, PX: 'static, QX: 'static, RX: 'static, SX: 'static, TX: 'static, UX: 'static, VX: 'static, WX: 'static, XX: 'static, YX: 'static, ZX: 'static, A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, N: EncoderFor<NX>, O: EncoderFor<OX>, P: EncoderFor<PX>, Q: EncoderFor<QX>, R: EncoderFor<RX>, S: EncoderFor<SX>, T: EncoderFor<TX>, U: EncoderFor<UX>, V: EncoderFor<VX>, W: EncoderFor<WX>, X: EncoderFor<XX>, Y: EncoderFor<YX>, Z: EncoderFor<ZX>, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<O, OX, P, PX, Q, QX, R, RX, S, SX, T, TX, U, UX, V, VX, W, WX, X, XX, Y, YX, Z, ZX, A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(OX, PX, QX, RX, SX, TX, UX, VX, WX, XX, YX, ZX, A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (O, P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where OX: 'static, PX: 'static, QX: 'static, RX: 'static, SX: 'static, TX: 'static, UX: 'static, VX: 'static, WX: 'static, XX: 'static, YX: 'static, ZX: 'static, A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, O: EncoderFor<OX>, P: EncoderFor<PX>, Q: EncoderFor<QX>, R: EncoderFor<RX>, S: EncoderFor<SX>, T: EncoderFor<TX>, U: EncoderFor<UX>, V: EncoderFor<VX>, W: EncoderFor<WX>, X: EncoderFor<XX>, Y: EncoderFor<YX>, Z: EncoderFor<ZX>, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<P, PX, Q, QX, R, RX, S, SX, T, TX, U, UX, V, VX, W, WX, X, XX, Y, YX, Z, ZX, A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(PX, QX, RX, SX, TX, UX, VX, WX, XX, YX, ZX, A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (P, Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where PX: 'static, QX: 'static, RX: 'static, SX: 'static, TX: 'static, UX: 'static, VX: 'static, WX: 'static, XX: 'static, YX: 'static, ZX: 'static, A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, P: EncoderFor<PX>, Q: EncoderFor<QX>, R: EncoderFor<RX>, S: EncoderFor<SX>, T: EncoderFor<TX>, U: EncoderFor<UX>, V: EncoderFor<VX>, W: EncoderFor<WX>, X: EncoderFor<XX>, Y: EncoderFor<YX>, Z: EncoderFor<ZX>, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<Q, QX, R, RX, S, SX, T, TX, U, UX, V, VX, W, WX, X, XX, Y, YX, Z, ZX, A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(QX, RX, SX, TX, UX, VX, WX, XX, YX, ZX, A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (Q, R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where QX: 'static, RX: 'static, SX: 'static, TX: 'static, UX: 'static, VX: 'static, WX: 'static, XX: 'static, YX: 'static, ZX: 'static, A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, Q: EncoderFor<QX>, R: EncoderFor<RX>, S: EncoderFor<SX>, T: EncoderFor<TX>, U: EncoderFor<UX>, V: EncoderFor<VX>, W: EncoderFor<WX>, X: EncoderFor<XX>, Y: EncoderFor<YX>, Z: EncoderFor<ZX>, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<R, RX, S, SX, T, TX, U, UX, V, VX, W, WX, X, XX, Y, YX, Z, ZX, A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(RX, SX, TX, UX, VX, WX, XX, YX, ZX, A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (R, S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where RX: 'static, SX: 'static, TX: 'static, UX: 'static, VX: 'static, WX: 'static, XX: 'static, YX: 'static, ZX: 'static, A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, R: EncoderFor<RX>, S: EncoderFor<SX>, T: EncoderFor<TX>, U: EncoderFor<UX>, V: EncoderFor<VX>, W: EncoderFor<WX>, X: EncoderFor<XX>, Y: EncoderFor<YX>, Z: EncoderFor<ZX>, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (S1, T1, U1, V1, W1, X1, Y1, Z1)

where S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<S, SX, T, TX, U, UX, V, VX, W, WX, X, XX, Y, YX, Z, ZX, A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(SX, TX, UX, VX, WX, XX, YX, ZX, A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (S, T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where SX: 'static, TX: 'static, UX: 'static, VX: 'static, WX: 'static, XX: 'static, YX: 'static, ZX: 'static, A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, S: EncoderFor<SX>, T: EncoderFor<TX>, U: EncoderFor<UX>, V: EncoderFor<VX>, W: EncoderFor<WX>, X: EncoderFor<XX>, Y: EncoderFor<YX>, Z: EncoderFor<ZX>, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (T1, U1, V1, W1, X1, Y1, Z1)

where T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<T> EncoderFor<Encoded<'static>> for Option<T>

where T: AsRef<[u8]>,

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<T, IT> EncoderFor<RestArray<'static, T>> for &[IT]

where T: DataType + DecoderFor<'static, T>, IT: EncoderFor<T>,

Slice encoder

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<T, IT> EncoderFor<RestArray<'static, T>> for &Vec<IT>

where T: DataType + DecoderFor<'static, T>, IT: EncoderFor<T>,

Direct &Vec encoder

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<T, IT> EncoderFor<RestArray<'static, T>> for Vec<IT>

where T: DataType + DecoderFor<'static, T>, IT: EncoderFor<T>,

Direct Vec encoder

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<T, IT> EncoderFor<ZTArray<'static, T>> for &[IT]

where T: DataType + DecoderFor<'static, T>, IT: EncoderFor<T>,

Slice encoder

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<T, IT> EncoderFor<ZTArray<'static, T>> for &Vec<IT>

where T: DataType + DecoderFor<'static, T>, IT: EncoderFor<T>,

Direct &Vec encoder

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<T, IT> EncoderFor<ZTArray<'static, T>> for Vec<IT>

where T: DataType + DecoderFor<'static, T>, IT: EncoderFor<T>,

Direct Vec encoder

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<T, L, IT> EncoderFor<Array<'static, L, T>> for &[IT]

where T: DataType + DecoderFor<'static, T>, L: DataType + 'static, IT: EncoderFor<T>,

Slice encoder

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<T, L, IT> EncoderFor<Array<'static, L, T>> for &Vec<IT>

where T: DataType + DecoderFor<'static, T>, L: DataType + 'static, IT: EncoderFor<T>,

Direct &Vec encoder

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<T, L, IT> EncoderFor<Array<'static, L, T>> for Vec<IT>

where T: DataType + DecoderFor<'static, T>, L: DataType + 'static, IT: EncoderFor<T>,

Direct Vec encoder

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<T, L, const N: usize, IT> EncoderFor<Array<'static, L, T>> for &[IT; N]

where T: DataType + DecoderFor<'static, T>, L: DataType + 'static, IT: EncoderFor<T>,

Array reference encoder

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<T, L, const N: usize, IT> EncoderFor<Array<'static, L, T>> for [IT; N]

where T: DataType + DecoderFor<'static, T>, L: DataType + 'static, IT: EncoderFor<T>,

Array encoder

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<T, TX, U, UX, V, VX, W, WX, X, XX, Y, YX, Z, ZX, A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(TX, UX, VX, WX, XX, YX, ZX, A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (T, U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where TX: 'static, UX: 'static, VX: 'static, WX: 'static, XX: 'static, YX: 'static, ZX: 'static, A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, T: EncoderFor<TX>, U: EncoderFor<UX>, V: EncoderFor<VX>, W: EncoderFor<WX>, X: EncoderFor<XX>, Y: EncoderFor<YX>, Z: EncoderFor<ZX>, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<T, const N: usize, IT> EncoderFor<RestArray<'static, T>> for &[IT; N]

where T: DataType + DecoderFor<'static, T>, IT: EncoderFor<T>,

Array reference encoder

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<T, const N: usize, IT> EncoderFor<RestArray<'static, T>> for [IT; N]

where T: DataType + DecoderFor<'static, T>, IT: EncoderFor<T>,

Array encoder

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<T, const N: usize, IT> EncoderFor<ZTArray<'static, T>> for &[IT; N]

where T: DataType + DecoderFor<'static, T>, IT: EncoderFor<T>,

Array reference encoder

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<T, const N: usize, IT> EncoderFor<ZTArray<'static, T>> for [IT; N]

where T: DataType + DecoderFor<'static, T>, IT: EncoderFor<T>,

Array encoder

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(U1X, V1X, W1X, X1X, Y1X, Z1X)> for (U1, V1, W1, X1, Y1, Z1)

where U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<U, UX, V, VX, W, WX, X, XX, Y, YX, Z, ZX, A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(UX, VX, WX, XX, YX, ZX, A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (U, V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where UX: 'static, VX: 'static, WX: 'static, XX: 'static, YX: 'static, ZX: 'static, A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, U: EncoderFor<UX>, V: EncoderFor<VX>, W: EncoderFor<WX>, X: EncoderFor<XX>, Y: EncoderFor<YX>, Z: EncoderFor<ZX>, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(V1X, W1X, X1X, Y1X, Z1X)> for (V1, W1, X1, Y1, Z1)

where V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<V, VX, W, WX, X, XX, Y, YX, Z, ZX, A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(VX, WX, XX, YX, ZX, A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (V, W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where VX: 'static, WX: 'static, XX: 'static, YX: 'static, ZX: 'static, A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, V: EncoderFor<VX>, W: EncoderFor<WX>, X: EncoderFor<XX>, Y: EncoderFor<YX>, Z: EncoderFor<ZX>, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(W1X, X1X, Y1X, Z1X)> for (W1, X1, Y1, Z1)

where W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<W, WX, X, XX, Y, YX, Z, ZX, A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(WX, XX, YX, ZX, A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (W, X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where WX: 'static, XX: 'static, YX: 'static, ZX: 'static, A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, W: EncoderFor<WX>, X: EncoderFor<XX>, Y: EncoderFor<YX>, Z: EncoderFor<ZX>, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(X1X, Y1X, Z1X)> for (X1, Y1, Z1)

where X1X: 'static, Y1X: 'static, Z1X: 'static, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<X, XX, Y, YX, Z, ZX, A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(XX, YX, ZX, A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (X, Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where XX: 'static, YX: 'static, ZX: 'static, A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, X: EncoderFor<XX>, Y: EncoderFor<YX>, Z: EncoderFor<ZX>, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<Y1, Y1X, Z1, Z1X> EncoderFor<(Y1X, Z1X)> for (Y1, Z1)

where Y1X: 'static, Z1X: 'static, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<Y, YX, Z, ZX, A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(YX, ZX, A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (Y, Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where YX: 'static, ZX: 'static, A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, Y: EncoderFor<YX>, Z: EncoderFor<ZX>, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<Z1, Z1X> EncoderFor<(Z1X,)> for (Z1,)

where Z1X: 'static, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<Z, ZX, A1, A1X, B1, B1X, C1, C1X, D1, D1X, E1, E1X, F1, F1X, G1, G1X, H1, H1X, I1, I1X, J1, J1X, K1, K1X, L1, L1X, M1, M1X, N1, N1X, O1, O1X, P1, P1X, Q1, Q1X, R1, R1X, S1, S1X, T1, T1X, U1, U1X, V1, V1X, W1, W1X, X1, X1X, Y1, Y1X, Z1, Z1X> EncoderFor<(ZX, A1X, B1X, C1X, D1X, E1X, F1X, G1X, H1X, I1X, J1X, K1X, L1X, M1X, N1X, O1X, P1X, Q1X, R1X, S1X, T1X, U1X, V1X, W1X, X1X, Y1X, Z1X)> for (Z, A1, B1, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where ZX: 'static, A1X: 'static, B1X: 'static, C1X: 'static, D1X: 'static, E1X: 'static, F1X: 'static, G1X: 'static, H1X: 'static, I1X: 'static, J1X: 'static, K1X: 'static, L1X: 'static, M1X: 'static, N1X: 'static, O1X: 'static, P1X: 'static, Q1X: 'static, R1X: 'static, S1X: 'static, T1X: 'static, U1X: 'static, V1X: 'static, W1X: 'static, X1X: 'static, Y1X: 'static, Z1X: 'static, Z: EncoderFor<ZX>, A1: EncoderFor<A1X>, B1: EncoderFor<B1X>, C1: EncoderFor<C1X>, D1: EncoderFor<D1X>, E1: EncoderFor<E1X>, F1: EncoderFor<F1X>, G1: EncoderFor<G1X>, H1: EncoderFor<H1X>, I1: EncoderFor<I1X>, J1: EncoderFor<J1X>, K1: EncoderFor<K1X>, L1: EncoderFor<L1X>, M1: EncoderFor<M1X>, N1: EncoderFor<N1X>, O1: EncoderFor<O1X>, P1: EncoderFor<P1X>, Q1: EncoderFor<Q1X>, R1: EncoderFor<R1X>, S1: EncoderFor<S1X>, T1: EncoderFor<T1X>, U1: EncoderFor<U1X>, V1: EncoderFor<V1X>, W1: EncoderFor<W1X>, X1: EncoderFor<X1X>, Y1: EncoderFor<Y1X>, Z1: EncoderFor<Z1X>,

Homomorphic mapping: If A: EncoderFor<A_X>, B: EncoderFor<B_X>, then (A, B): EncoderFor<(A_X, B_X)>

fn encode_for(&self, buf: &mut BufWriter<'_>)

impl<const N: usize, T, U> EncoderFor<[T; N]> for [U; N]

where T: DataType + 'static, U: EncoderFor<T>,

fn encode_for(&self, buf: &mut BufWriter<'_>)

Implementors

impl EncoderFor<Encoded<'static>> for &Encoded<'_>

impl EncoderFor<Encoded<'static>> for Encoded<'_>

impl EncoderFor<DescribeAspect> for &DescribeAspect

impl EncoderFor<DescribeAspect> for DescribeAspect

impl EncoderFor<InputLanguage> for &InputLanguage

impl EncoderFor<InputLanguage> for InputLanguage

impl EncoderFor<IoFormat> for &IoFormat

impl EncoderFor<IoFormat> for IoFormat

impl EncoderFor<TransactionState> for &TransactionState

impl EncoderFor<TransactionState> for TransactionState

impl EncoderFor<Length> for Length

impl EncoderFor<Uuid> for &Uuid

impl EncoderFor<Uuid> for Uuid

impl EncoderFor<AuthenticationOk<'static>> for &AuthenticationOkBuilder

impl EncoderFor<AuthenticationOk<'static>> for AuthenticationOkBuilder

impl EncoderFor<RestoreEof<'static>> for &RestoreEofBuilder

impl EncoderFor<RestoreEof<'static>> for RestoreEofBuilder

impl EncoderFor<Sync<'static>> for &SyncBuilder

impl EncoderFor<Sync<'static>> for SyncBuilder

impl EncoderFor<Terminate<'static>> for &TerminateBuilder

impl EncoderFor<Terminate<'static>> for TerminateBuilder

impl<'a> EncoderFor<Annotation<'static>> for Annotation<'a>

impl<'a> EncoderFor<Authentication<'static>> for Authentication<'a>

impl<'a> EncoderFor<AuthenticationOk<'static>> for AuthenticationOk<'a>

impl<'a> EncoderFor<AuthenticationRequiredSASLMessage<'static>> for AuthenticationRequiredSASLMessage<'a>

impl<'a> EncoderFor<AuthenticationSASLContinue<'static>> for AuthenticationSASLContinue<'a>

impl<'a> EncoderFor<AuthenticationSASLFinal<'static>> for AuthenticationSASLFinal<'a>

impl<'a> EncoderFor<AuthenticationSASLInitialResponse<'static>> for AuthenticationSASLInitialResponse<'a>

impl<'a> EncoderFor<AuthenticationSASLResponse<'static>> for AuthenticationSASLResponse<'a>

impl<'a> EncoderFor<ClientHandshake<'static>> for ClientHandshake<'a>

impl<'a> EncoderFor<CommandComplete<'static>> for CommandComplete<'a>

impl<'a> EncoderFor<CommandDataDescription<'static>> for CommandDataDescription<'a>

impl<'a> EncoderFor<ConnectionParam<'static>> for ConnectionParam<'a>

impl<'a> EncoderFor<Data<'static>> for Data<'a>

impl<'a> EncoderFor<DataElement<'static>> for DataElement<'a>

impl<'a> EncoderFor<Dump2<'static>> for Dump2<'a>

impl<'a> EncoderFor<Dump3<'static>> for Dump3<'a>

impl<'a> EncoderFor<Dump<'static>> for Dump<'a>

impl<'a> EncoderFor<DumpBlock<'static>> for DumpBlock<'a>

impl<'a> EncoderFor<DumpHeader<'static>> for DumpHeader<'a>

impl<'a> EncoderFor<DumpObjectDesc<'static>> for DumpObjectDesc<'a>

impl<'a> EncoderFor<DumpTypeInfo<'static>> for DumpTypeInfo<'a>

impl<'a> EncoderFor<ErrorResponse<'static>> for ErrorResponse<'a>

impl<'a> EncoderFor<Execute2<'static>> for Execute2<'a>

impl<'a> EncoderFor<Execute<'static>> for Execute<'a>

impl<'a> EncoderFor<KeyValue<'static>> for KeyValue<'a>

impl<'a> EncoderFor<LogMessage<'static>> for LogMessage<'a>

impl<'a> EncoderFor<Message<'static>> for Message<'a>

impl<'a> EncoderFor<ParameterStatus<'static>> for ParameterStatus<'a>

impl<'a> EncoderFor<Parse2<'static>> for Parse2<'a>

impl<'a> EncoderFor<Parse<'static>> for Parse<'a>

impl<'a> EncoderFor<ProtocolExtension<'static>> for ProtocolExtension<'a>

impl<'a> EncoderFor<ReadyForCommand<'static>> for ReadyForCommand<'a>

impl<'a> EncoderFor<Restore<'static>> for Restore<'a>

impl<'a> EncoderFor<RestoreBlock<'static>> for RestoreBlock<'a>

impl<'a> EncoderFor<RestoreEof<'static>> for RestoreEof<'a>

impl<'a> EncoderFor<RestoreReady<'static>> for RestoreReady<'a>

impl<'a> EncoderFor<ServerHandshake<'static>> for ServerHandshake<'a>

impl<'a> EncoderFor<ServerKeyData<'static>> for ServerKeyData<'a>

impl<'a> EncoderFor<StateDataDescription<'static>> for StateDataDescription<'a>

impl<'a> EncoderFor<Sync<'static>> for Sync<'a>

impl<'a> EncoderFor<Terminate<'static>> for Terminate<'a>

impl<ANNOTATIONS> EncoderFor<Dump<'static>> for &DumpBuilder<ANNOTATIONS>

where ANNOTATIONS: EncoderFor<Array<'static, i16, Annotation<'static>>>,

impl<ANNOTATIONS> EncoderFor<Dump<'static>> for DumpBuilder<ANNOTATIONS>

where ANNOTATIONS: EncoderFor<Array<'static, i16, Annotation<'static>>>,

impl<ANNOTATIONS, ALLOWED_CAPABILITIES, COMPILATION_FLAGS, IMPLICIT_LIMIT, INPUT_LANGUAGE, OUTPUT_FORMAT, EXPECTED_CARDINALITY, COMMAND_TEXT, STATE_TYPEDESC_ID, STATE_DATA> EncoderFor<Parse<'static>> for &ParseBuilder<ANNOTATIONS, ALLOWED_CAPABILITIES, COMPILATION_FLAGS, IMPLICIT_LIMIT, INPUT_LANGUAGE, OUTPUT_FORMAT, EXPECTED_CARDINALITY, COMMAND_TEXT, STATE_TYPEDESC_ID, STATE_DATA>

where ANNOTATIONS: EncoderFor<Array<'static, i16, Annotation<'static>>>, ALLOWED_CAPABILITIES: EncoderFor<u64>, COMPILATION_FLAGS: EncoderFor<u64>, IMPLICIT_LIMIT: EncoderFor<u64>, INPUT_LANGUAGE: EncoderFor<InputLanguage>, OUTPUT_FORMAT: EncoderFor<IoFormat>, EXPECTED_CARDINALITY: EncoderFor<u8>, COMMAND_TEXT: EncoderFor<LString<'static>>, STATE_TYPEDESC_ID: EncoderFor<Uuid>, STATE_DATA: EncoderFor<Array<'static, u32, u8>>,

impl<ANNOTATIONS, ALLOWED_CAPABILITIES, COMPILATION_FLAGS, IMPLICIT_LIMIT, INPUT_LANGUAGE, OUTPUT_FORMAT, EXPECTED_CARDINALITY, COMMAND_TEXT, STATE_TYPEDESC_ID, STATE_DATA> EncoderFor<Parse<'static>> for ParseBuilder<ANNOTATIONS, ALLOWED_CAPABILITIES, COMPILATION_FLAGS, IMPLICIT_LIMIT, INPUT_LANGUAGE, OUTPUT_FORMAT, EXPECTED_CARDINALITY, COMMAND_TEXT, STATE_TYPEDESC_ID, STATE_DATA>

where ANNOTATIONS: EncoderFor<Array<'static, i16, Annotation<'static>>>, ALLOWED_CAPABILITIES: EncoderFor<u64>, COMPILATION_FLAGS: EncoderFor<u64>, IMPLICIT_LIMIT: EncoderFor<u64>, INPUT_LANGUAGE: EncoderFor<InputLanguage>, OUTPUT_FORMAT: EncoderFor<IoFormat>, EXPECTED_CARDINALITY: EncoderFor<u8>, COMMAND_TEXT: EncoderFor<LString<'static>>, STATE_TYPEDESC_ID: EncoderFor<Uuid>, STATE_DATA: EncoderFor<Array<'static, u32, u8>>,

impl<ANNOTATIONS, ALLOWED_CAPABILITIES, COMPILATION_FLAGS, IMPLICIT_LIMIT, INPUT_LANGUAGE, OUTPUT_FORMAT, EXPECTED_CARDINALITY, COMMAND_TEXT, STATE_TYPEDESC_ID, STATE_DATA, INPUT_TYPEDESC_ID, OUTPUT_TYPEDESC_ID, ARGUMENTS> EncoderFor<Execute<'static>> for &ExecuteBuilder<ANNOTATIONS, ALLOWED_CAPABILITIES, COMPILATION_FLAGS, IMPLICIT_LIMIT, INPUT_LANGUAGE, OUTPUT_FORMAT, EXPECTED_CARDINALITY, COMMAND_TEXT, STATE_TYPEDESC_ID, STATE_DATA, INPUT_TYPEDESC_ID, OUTPUT_TYPEDESC_ID, ARGUMENTS>

where ANNOTATIONS: EncoderFor<Array<'static, i16, Annotation<'static>>>, ALLOWED_CAPABILITIES: EncoderFor<u64>, COMPILATION_FLAGS: EncoderFor<u64>, IMPLICIT_LIMIT: EncoderFor<u64>, INPUT_LANGUAGE: EncoderFor<InputLanguage>, OUTPUT_FORMAT: EncoderFor<IoFormat>, EXPECTED_CARDINALITY: EncoderFor<u8>, COMMAND_TEXT: EncoderFor<LString<'static>>, STATE_TYPEDESC_ID: EncoderFor<Uuid>, STATE_DATA: EncoderFor<Array<'static, u32, u8>>, INPUT_TYPEDESC_ID: EncoderFor<Uuid>, OUTPUT_TYPEDESC_ID: EncoderFor<Uuid>, ARGUMENTS: EncoderFor<Array<'static, u32, u8>>,

impl<ANNOTATIONS, ALLOWED_CAPABILITIES, COMPILATION_FLAGS, IMPLICIT_LIMIT, INPUT_LANGUAGE, OUTPUT_FORMAT, EXPECTED_CARDINALITY, COMMAND_TEXT, STATE_TYPEDESC_ID, STATE_DATA, INPUT_TYPEDESC_ID, OUTPUT_TYPEDESC_ID, ARGUMENTS> EncoderFor<Execute<'static>> for ExecuteBuilder<ANNOTATIONS, ALLOWED_CAPABILITIES, COMPILATION_FLAGS, IMPLICIT_LIMIT, INPUT_LANGUAGE, OUTPUT_FORMAT, EXPECTED_CARDINALITY, COMMAND_TEXT, STATE_TYPEDESC_ID, STATE_DATA, INPUT_TYPEDESC_ID, OUTPUT_TYPEDESC_ID, ARGUMENTS>

where ANNOTATIONS: EncoderFor<Array<'static, i16, Annotation<'static>>>, ALLOWED_CAPABILITIES: EncoderFor<u64>, COMPILATION_FLAGS: EncoderFor<u64>, IMPLICIT_LIMIT: EncoderFor<u64>, INPUT_LANGUAGE: EncoderFor<InputLanguage>, OUTPUT_FORMAT: EncoderFor<IoFormat>, EXPECTED_CARDINALITY: EncoderFor<u8>, COMMAND_TEXT: EncoderFor<LString<'static>>, STATE_TYPEDESC_ID: EncoderFor<Uuid>, STATE_DATA: EncoderFor<Array<'static, u32, u8>>, INPUT_TYPEDESC_ID: EncoderFor<Uuid>, OUTPUT_TYPEDESC_ID: EncoderFor<Uuid>, ARGUMENTS: EncoderFor<Array<'static, u32, u8>>,

impl<ANNOTATIONS, ALLOWED_CAPABILITIES, COMPILATION_FLAGS, IMPLICIT_LIMIT, OUTPUT_FORMAT, EXPECTED_CARDINALITY, COMMAND_TEXT, STATE_TYPEDESC_ID, STATE_DATA> EncoderFor<Parse2<'static>> for &Parse2Builder<ANNOTATIONS, ALLOWED_CAPABILITIES, COMPILATION_FLAGS, IMPLICIT_LIMIT, OUTPUT_FORMAT, EXPECTED_CARDINALITY, COMMAND_TEXT, STATE_TYPEDESC_ID, STATE_DATA>

where ANNOTATIONS: EncoderFor<Array<'static, i16, Annotation<'static>>>, ALLOWED_CAPABILITIES: EncoderFor<u64>, COMPILATION_FLAGS: EncoderFor<u64>, IMPLICIT_LIMIT: EncoderFor<u64>, OUTPUT_FORMAT: EncoderFor<IoFormat>, EXPECTED_CARDINALITY: EncoderFor<u8>, COMMAND_TEXT: EncoderFor<LString<'static>>, STATE_TYPEDESC_ID: EncoderFor<Uuid>, STATE_DATA: EncoderFor<Array<'static, u32, u8>>,

impl<ANNOTATIONS, ALLOWED_CAPABILITIES, COMPILATION_FLAGS, IMPLICIT_LIMIT, OUTPUT_FORMAT, EXPECTED_CARDINALITY, COMMAND_TEXT, STATE_TYPEDESC_ID, STATE_DATA> EncoderFor<Parse2<'static>> for Parse2Builder<ANNOTATIONS, ALLOWED_CAPABILITIES, COMPILATION_FLAGS, IMPLICIT_LIMIT, OUTPUT_FORMAT, EXPECTED_CARDINALITY, COMMAND_TEXT, STATE_TYPEDESC_ID, STATE_DATA>

where ANNOTATIONS: EncoderFor<Array<'static, i16, Annotation<'static>>>, ALLOWED_CAPABILITIES: EncoderFor<u64>, COMPILATION_FLAGS: EncoderFor<u64>, IMPLICIT_LIMIT: EncoderFor<u64>, OUTPUT_FORMAT: EncoderFor<IoFormat>, EXPECTED_CARDINALITY: EncoderFor<u8>, COMMAND_TEXT: EncoderFor<LString<'static>>, STATE_TYPEDESC_ID: EncoderFor<Uuid>, STATE_DATA: EncoderFor<Array<'static, u32, u8>>,

impl<ANNOTATIONS, ALLOWED_CAPABILITIES, COMPILATION_FLAGS, IMPLICIT_LIMIT, OUTPUT_FORMAT, EXPECTED_CARDINALITY, COMMAND_TEXT, STATE_TYPEDESC_ID, STATE_DATA, INPUT_TYPEDESC_ID, OUTPUT_TYPEDESC_ID, ARGUMENTS> EncoderFor<Execute2<'static>> for &Execute2Builder<ANNOTATIONS, ALLOWED_CAPABILITIES, COMPILATION_FLAGS, IMPLICIT_LIMIT, OUTPUT_FORMAT, EXPECTED_CARDINALITY, COMMAND_TEXT, STATE_TYPEDESC_ID, STATE_DATA, INPUT_TYPEDESC_ID, OUTPUT_TYPEDESC_ID, ARGUMENTS>

where ANNOTATIONS: EncoderFor<Array<'static, i16, Annotation<'static>>>, ALLOWED_CAPABILITIES: EncoderFor<u64>, COMPILATION_FLAGS: EncoderFor<u64>, IMPLICIT_LIMIT: EncoderFor<u64>, OUTPUT_FORMAT: EncoderFor<IoFormat>, EXPECTED_CARDINALITY: EncoderFor<u8>, COMMAND_TEXT: EncoderFor<LString<'static>>, STATE_TYPEDESC_ID: EncoderFor<Uuid>, STATE_DATA: EncoderFor<Array<'static, u32, u8>>, INPUT_TYPEDESC_ID: EncoderFor<Uuid>, OUTPUT_TYPEDESC_ID: EncoderFor<Uuid>, ARGUMENTS: EncoderFor<Array<'static, u32, u8>>,

impl<ANNOTATIONS, ALLOWED_CAPABILITIES, COMPILATION_FLAGS, IMPLICIT_LIMIT, OUTPUT_FORMAT, EXPECTED_CARDINALITY, COMMAND_TEXT, STATE_TYPEDESC_ID, STATE_DATA, INPUT_TYPEDESC_ID, OUTPUT_TYPEDESC_ID, ARGUMENTS> EncoderFor<Execute2<'static>> for Execute2Builder<ANNOTATIONS, ALLOWED_CAPABILITIES, COMPILATION_FLAGS, IMPLICIT_LIMIT, OUTPUT_FORMAT, EXPECTED_CARDINALITY, COMMAND_TEXT, STATE_TYPEDESC_ID, STATE_DATA, INPUT_TYPEDESC_ID, OUTPUT_TYPEDESC_ID, ARGUMENTS>

where ANNOTATIONS: EncoderFor<Array<'static, i16, Annotation<'static>>>, ALLOWED_CAPABILITIES: EncoderFor<u64>, COMPILATION_FLAGS: EncoderFor<u64>, IMPLICIT_LIMIT: EncoderFor<u64>, OUTPUT_FORMAT: EncoderFor<IoFormat>, EXPECTED_CARDINALITY: EncoderFor<u8>, COMMAND_TEXT: EncoderFor<LString<'static>>, STATE_TYPEDESC_ID: EncoderFor<Uuid>, STATE_DATA: EncoderFor<Array<'static, u32, u8>>, INPUT_TYPEDESC_ID: EncoderFor<Uuid>, OUTPUT_TYPEDESC_ID: EncoderFor<Uuid>, ARGUMENTS: EncoderFor<Array<'static, u32, u8>>,

impl<ANNOTATIONS, CAPABILITIES, RESULT_CARDINALITY, INPUT_TYPEDESC_ID, INPUT_TYPEDESC, OUTPUT_TYPEDESC_ID, OUTPUT_TYPEDESC> EncoderFor<CommandDataDescription<'static>> for &CommandDataDescriptionBuilder<ANNOTATIONS, CAPABILITIES, RESULT_CARDINALITY, INPUT_TYPEDESC_ID, INPUT_TYPEDESC, OUTPUT_TYPEDESC_ID, OUTPUT_TYPEDESC>

where ANNOTATIONS: EncoderFor<Array<'static, i16, Annotation<'static>>>, CAPABILITIES: EncoderFor<u64>, RESULT_CARDINALITY: EncoderFor<u8>, INPUT_TYPEDESC_ID: EncoderFor<Uuid>, INPUT_TYPEDESC: EncoderFor<Array<'static, u32, u8>>, OUTPUT_TYPEDESC_ID: EncoderFor<Uuid>, OUTPUT_TYPEDESC: EncoderFor<Array<'static, u32, u8>>,

impl<ANNOTATIONS, CAPABILITIES, RESULT_CARDINALITY, INPUT_TYPEDESC_ID, INPUT_TYPEDESC, OUTPUT_TYPEDESC_ID, OUTPUT_TYPEDESC> EncoderFor<CommandDataDescription<'static>> for CommandDataDescriptionBuilder<ANNOTATIONS, CAPABILITIES, RESULT_CARDINALITY, INPUT_TYPEDESC_ID, INPUT_TYPEDESC, OUTPUT_TYPEDESC_ID, OUTPUT_TYPEDESC>

where ANNOTATIONS: EncoderFor<Array<'static, i16, Annotation<'static>>>, CAPABILITIES: EncoderFor<u64>, RESULT_CARDINALITY: EncoderFor<u8>, INPUT_TYPEDESC_ID: EncoderFor<Uuid>, INPUT_TYPEDESC: EncoderFor<Array<'static, u32, u8>>, OUTPUT_TYPEDESC_ID: EncoderFor<Uuid>, OUTPUT_TYPEDESC: EncoderFor<Array<'static, u32, u8>>,

impl<ANNOTATIONS, CAPABILITIES, STATUS, STATE_TYPEDESC_ID, STATE_DATA> EncoderFor<CommandComplete<'static>> for &CommandCompleteBuilder<ANNOTATIONS, CAPABILITIES, STATUS, STATE_TYPEDESC_ID, STATE_DATA>

where ANNOTATIONS: EncoderFor<Array<'static, i16, Annotation<'static>>>, CAPABILITIES: EncoderFor<u64>, STATUS: EncoderFor<LString<'static>>, STATE_TYPEDESC_ID: EncoderFor<Uuid>, STATE_DATA: EncoderFor<Array<'static, u32, u8>>,

impl<ANNOTATIONS, CAPABILITIES, STATUS, STATE_TYPEDESC_ID, STATE_DATA> EncoderFor<CommandComplete<'static>> for CommandCompleteBuilder<ANNOTATIONS, CAPABILITIES, STATUS, STATE_TYPEDESC_ID, STATE_DATA>

where ANNOTATIONS: EncoderFor<Array<'static, i16, Annotation<'static>>>, CAPABILITIES: EncoderFor<u64>, STATUS: EncoderFor<LString<'static>>, STATE_TYPEDESC_ID: EncoderFor<Uuid>, STATE_DATA: EncoderFor<Array<'static, u32, u8>>,

impl<ANNOTATIONS, FLAGS> EncoderFor<Dump3<'static>> for &Dump3Builder<ANNOTATIONS, FLAGS>

where ANNOTATIONS: EncoderFor<Array<'static, i16, Annotation<'static>>>, FLAGS: EncoderFor<u64>,

impl<ANNOTATIONS, FLAGS> EncoderFor<Dump3<'static>> for Dump3Builder<ANNOTATIONS, FLAGS>

where ANNOTATIONS: EncoderFor<Array<'static, i16, Annotation<'static>>>, FLAGS: EncoderFor<u64>,

impl<ANNOTATIONS, TRANSACTION_STATE> EncoderFor<ReadyForCommand<'static>> for &ReadyForCommandBuilder<ANNOTATIONS, TRANSACTION_STATE>

where ANNOTATIONS: EncoderFor<Array<'static, i16, Annotation<'static>>>, TRANSACTION_STATE: EncoderFor<TransactionState>,

impl<ANNOTATIONS, TRANSACTION_STATE> EncoderFor<ReadyForCommand<'static>> for ReadyForCommandBuilder<ANNOTATIONS, TRANSACTION_STATE>

where ANNOTATIONS: EncoderFor<Array<'static, i16, Annotation<'static>>>, TRANSACTION_STATE: EncoderFor<TransactionState>,

impl<ATTRIBUTES> EncoderFor<DumpBlock<'static>> for &DumpBlockBuilder<ATTRIBUTES>

where ATTRIBUTES: EncoderFor<Array<'static, i16, KeyValue<'static>>>,

impl<ATTRIBUTES> EncoderFor<DumpBlock<'static>> for DumpBlockBuilder<ATTRIBUTES>

where ATTRIBUTES: EncoderFor<Array<'static, i16, KeyValue<'static>>>,

impl<ATTRIBUTES, MAJOR_VER, MINOR_VER, SCHEMA_DDL, TYPES, DESCRIPTORS> EncoderFor<DumpHeader<'static>> for &DumpHeaderBuilder<ATTRIBUTES, MAJOR_VER, MINOR_VER, SCHEMA_DDL, TYPES, DESCRIPTORS>

where ATTRIBUTES: EncoderFor<Array<'static, i16, KeyValue<'static>>>, MAJOR_VER: EncoderFor<i16>, MINOR_VER: EncoderFor<i16>, SCHEMA_DDL: EncoderFor<LString<'static>>, TYPES: EncoderFor<Array<'static, i32, DumpTypeInfo<'static>>>, DESCRIPTORS: EncoderFor<Array<'static, i32, DumpObjectDesc<'static>>>,

impl<ATTRIBUTES, MAJOR_VER, MINOR_VER, SCHEMA_DDL, TYPES, DESCRIPTORS> EncoderFor<DumpHeader<'static>> for DumpHeaderBuilder<ATTRIBUTES, MAJOR_VER, MINOR_VER, SCHEMA_DDL, TYPES, DESCRIPTORS>

where ATTRIBUTES: EncoderFor<Array<'static, i16, KeyValue<'static>>>, MAJOR_VER: EncoderFor<i16>, MINOR_VER: EncoderFor<i16>, SCHEMA_DDL: EncoderFor<LString<'static>>, TYPES: EncoderFor<Array<'static, i32, DumpTypeInfo<'static>>>, DESCRIPTORS: EncoderFor<Array<'static, i32, DumpObjectDesc<'static>>>,

impl<AUTH_STATUS, DATA> EncoderFor<Authentication<'static>> for &AuthenticationBuilder<AUTH_STATUS, DATA>

where AUTH_STATUS: EncoderFor<i32>, DATA: EncoderFor<Rest<'static>>,

impl<AUTH_STATUS, DATA> EncoderFor<Authentication<'static>> for AuthenticationBuilder<AUTH_STATUS, DATA>

where AUTH_STATUS: EncoderFor<i32>, DATA: EncoderFor<Rest<'static>>,

impl<BLOCK_DATA> EncoderFor<RestoreBlock<'static>> for &RestoreBlockBuilder<BLOCK_DATA>

where BLOCK_DATA: EncoderFor<Array<'static, u32, u8>>,

impl<BLOCK_DATA> EncoderFor<RestoreBlock<'static>> for RestoreBlockBuilder<BLOCK_DATA>

where BLOCK_DATA: EncoderFor<Array<'static, u32, u8>>,

impl<CODE, VALUE> EncoderFor<KeyValue<'static>> for &KeyValueBuilder<CODE, VALUE>

where CODE: EncoderFor<u16>, VALUE: EncoderFor<Array<'static, u32, u8>>,

impl<CODE, VALUE> EncoderFor<KeyValue<'static>> for KeyValueBuilder<CODE, VALUE>

where CODE: EncoderFor<u16>, VALUE: EncoderFor<Array<'static, u32, u8>>,

impl<DATA> EncoderFor<Data<'static>> for &DataBuilder<DATA>

where DATA: EncoderFor<Array<'static, i16, DataElement<'static>>>,

impl<DATA> EncoderFor<Data<'static>> for DataBuilder<DATA>

where DATA: EncoderFor<Array<'static, i16, DataElement<'static>>>,

impl<DATA> EncoderFor<DataElement<'static>> for &DataElementBuilder<DATA>

where DATA: EncoderFor<Array<'static, i32, u8>>,

impl<DATA> EncoderFor<DataElement<'static>> for DataElementBuilder<DATA>

where DATA: EncoderFor<Array<'static, i32, u8>>,

impl<DATA> EncoderFor<ServerKeyData<'static>> for &ServerKeyDataBuilder<DATA>

where DATA: EncoderFor<[u8; 32]>,

impl<DATA> EncoderFor<ServerKeyData<'static>> for ServerKeyDataBuilder<DATA>

where DATA: EncoderFor<[u8; 32]>,

impl<HEADERS> EncoderFor<Dump2<'static>> for &Dump2Builder<HEADERS>

where HEADERS: EncoderFor<Array<'static, i16, KeyValue<'static>>>,

impl<HEADERS> EncoderFor<Dump2<'static>> for Dump2Builder<HEADERS>

where HEADERS: EncoderFor<Array<'static, i16, KeyValue<'static>>>,

impl<HEADERS, JOBS> EncoderFor<RestoreReady<'static>> for &RestoreReadyBuilder<HEADERS, JOBS>

where HEADERS: EncoderFor<Array<'static, i16, KeyValue<'static>>>, JOBS: EncoderFor<u16>,

impl<HEADERS, JOBS> EncoderFor<RestoreReady<'static>> for RestoreReadyBuilder<HEADERS, JOBS>

where HEADERS: EncoderFor<Array<'static, i16, KeyValue<'static>>>, JOBS: EncoderFor<u16>,

impl<HEADERS, JOBS, DATA> EncoderFor<Restore<'static>> for &RestoreBuilder<HEADERS, JOBS, DATA>

where HEADERS: EncoderFor<Array<'static, i16, KeyValue<'static>>>, JOBS: EncoderFor<u16>, DATA: EncoderFor<Rest<'static>>,

impl<HEADERS, JOBS, DATA> EncoderFor<Restore<'static>> for RestoreBuilder<HEADERS, JOBS, DATA>

where HEADERS: EncoderFor<Array<'static, i16, KeyValue<'static>>>, JOBS: EncoderFor<u16>, DATA: EncoderFor<Rest<'static>>,

impl<MAJOR_VER, MINOR_VER, EXTENSIONS> EncoderFor<ServerHandshake<'static>> for &ServerHandshakeBuilder<MAJOR_VER, MINOR_VER, EXTENSIONS>

where MAJOR_VER: EncoderFor<u16>, MINOR_VER: EncoderFor<u16>, EXTENSIONS: EncoderFor<Array<'static, i16, ProtocolExtension<'static>>>,

impl<MAJOR_VER, MINOR_VER, EXTENSIONS> EncoderFor<ServerHandshake<'static>> for ServerHandshakeBuilder<MAJOR_VER, MINOR_VER, EXTENSIONS>

where MAJOR_VER: EncoderFor<u16>, MINOR_VER: EncoderFor<u16>, EXTENSIONS: EncoderFor<Array<'static, i16, ProtocolExtension<'static>>>,

impl<MAJOR_VER, MINOR_VER, PARAMS, EXTENSIONS> EncoderFor<ClientHandshake<'static>> for &ClientHandshakeBuilder<MAJOR_VER, MINOR_VER, PARAMS, EXTENSIONS>

where MAJOR_VER: EncoderFor<u16>, MINOR_VER: EncoderFor<u16>, PARAMS: EncoderFor<Array<'static, i16, ConnectionParam<'static>>>, EXTENSIONS: EncoderFor<Array<'static, i16, ProtocolExtension<'static>>>,

impl<MAJOR_VER, MINOR_VER, PARAMS, EXTENSIONS> EncoderFor<ClientHandshake<'static>> for ClientHandshakeBuilder<MAJOR_VER, MINOR_VER, PARAMS, EXTENSIONS>

where MAJOR_VER: EncoderFor<u16>, MINOR_VER: EncoderFor<u16>, PARAMS: EncoderFor<Array<'static, i16, ConnectionParam<'static>>>, EXTENSIONS: EncoderFor<Array<'static, i16, ProtocolExtension<'static>>>,

impl<METHOD, SASL_DATA> EncoderFor<AuthenticationSASLInitialResponse<'static>> for &AuthenticationSASLInitialResponseBuilder<METHOD, SASL_DATA>

where METHOD: EncoderFor<LString<'static>>, SASL_DATA: EncoderFor<Array<'static, u32, u8>>,

impl<METHOD, SASL_DATA> EncoderFor<AuthenticationSASLInitialResponse<'static>> for AuthenticationSASLInitialResponseBuilder<METHOD, SASL_DATA>

where METHOD: EncoderFor<LString<'static>>, SASL_DATA: EncoderFor<Array<'static, u32, u8>>,

impl<METHODS> EncoderFor<AuthenticationRequiredSASLMessage<'static>> for &AuthenticationRequiredSASLMessageBuilder<METHODS>

where METHODS: EncoderFor<Array<'static, i32, LString<'static>>>,

impl<METHODS> EncoderFor<AuthenticationRequiredSASLMessage<'static>> for AuthenticationRequiredSASLMessageBuilder<METHODS>

where METHODS: EncoderFor<Array<'static, i32, LString<'static>>>,

impl<MTYPE, DATA> EncoderFor<Message<'static>> for &MessageBuilder<MTYPE, DATA>

where MTYPE: EncoderFor<u8>, DATA: EncoderFor<Rest<'static>>,

impl<MTYPE, DATA> EncoderFor<Message<'static>> for MessageBuilder<MTYPE, DATA>

where MTYPE: EncoderFor<u8>, DATA: EncoderFor<Rest<'static>>,

impl<NAME, ANNOTATIONS> EncoderFor<ProtocolExtension<'static>> for &ProtocolExtensionBuilder<NAME, ANNOTATIONS>

where NAME: EncoderFor<LString<'static>>, ANNOTATIONS: EncoderFor<Array<'static, i16, Annotation<'static>>>,

impl<NAME, ANNOTATIONS> EncoderFor<ProtocolExtension<'static>> for ProtocolExtensionBuilder<NAME, ANNOTATIONS>

where NAME: EncoderFor<LString<'static>>, ANNOTATIONS: EncoderFor<Array<'static, i16, Annotation<'static>>>,

impl<NAME, VALUE> EncoderFor<Annotation<'static>> for &AnnotationBuilder<NAME, VALUE>

where NAME: EncoderFor<LString<'static>>, VALUE: EncoderFor<LString<'static>>,

impl<NAME, VALUE> EncoderFor<Annotation<'static>> for AnnotationBuilder<NAME, VALUE>

where NAME: EncoderFor<LString<'static>>, VALUE: EncoderFor<LString<'static>>,

impl<NAME, VALUE> EncoderFor<ConnectionParam<'static>> for &ConnectionParamBuilder<NAME, VALUE>

where NAME: EncoderFor<LString<'static>>, VALUE: EncoderFor<LString<'static>>,

impl<NAME, VALUE> EncoderFor<ConnectionParam<'static>> for ConnectionParamBuilder<NAME, VALUE>

where NAME: EncoderFor<LString<'static>>, VALUE: EncoderFor<LString<'static>>,

impl<NAME, VALUE> EncoderFor<ParameterStatus<'static>> for &ParameterStatusBuilder<NAME, VALUE>

where NAME: EncoderFor<Array<'static, u32, u8>>, VALUE: EncoderFor<Array<'static, u32, u8>>,

impl<NAME, VALUE> EncoderFor<ParameterStatus<'static>> for ParameterStatusBuilder<NAME, VALUE>

where NAME: EncoderFor<Array<'static, u32, u8>>, VALUE: EncoderFor<Array<'static, u32, u8>>,

impl<OBJECT_ID, DESCRIPTION, DEPENDENCIES> EncoderFor<DumpObjectDesc<'static>> for &DumpObjectDescBuilder<OBJECT_ID, DESCRIPTION, DEPENDENCIES>

where OBJECT_ID: EncoderFor<Uuid>, DESCRIPTION: EncoderFor<Array<'static, u32, u8>>, DEPENDENCIES: EncoderFor<Array<'static, i16, Uuid>>,

impl<OBJECT_ID, DESCRIPTION, DEPENDENCIES> EncoderFor<DumpObjectDesc<'static>> for DumpObjectDescBuilder<OBJECT_ID, DESCRIPTION, DEPENDENCIES>

where OBJECT_ID: EncoderFor<Uuid>, DESCRIPTION: EncoderFor<Array<'static, u32, u8>>, DEPENDENCIES: EncoderFor<Array<'static, i16, Uuid>>,

impl<SASL_DATA> EncoderFor<AuthenticationSASLContinue<'static>> for &AuthenticationSASLContinueBuilder<SASL_DATA>

where SASL_DATA: EncoderFor<Array<'static, u32, u8>>,

impl<SASL_DATA> EncoderFor<AuthenticationSASLContinue<'static>> for AuthenticationSASLContinueBuilder<SASL_DATA>

where SASL_DATA: EncoderFor<Array<'static, u32, u8>>,

impl<SASL_DATA> EncoderFor<AuthenticationSASLFinal<'static>> for &AuthenticationSASLFinalBuilder<SASL_DATA>

where SASL_DATA: EncoderFor<Array<'static, u32, u8>>,

impl<SASL_DATA> EncoderFor<AuthenticationSASLFinal<'static>> for AuthenticationSASLFinalBuilder<SASL_DATA>

where SASL_DATA: EncoderFor<Array<'static, u32, u8>>,

impl<SASL_DATA> EncoderFor<AuthenticationSASLResponse<'static>> for &AuthenticationSASLResponseBuilder<SASL_DATA>

where SASL_DATA: EncoderFor<Array<'static, u32, u8>>,

impl<SASL_DATA> EncoderFor<AuthenticationSASLResponse<'static>> for AuthenticationSASLResponseBuilder<SASL_DATA>

where SASL_DATA: EncoderFor<Array<'static, u32, u8>>,

impl<SEVERITY, CODE, TEXT, ANNOTATIONS> EncoderFor<LogMessage<'static>> for &LogMessageBuilder<SEVERITY, CODE, TEXT, ANNOTATIONS>

where SEVERITY: EncoderFor<u8>, CODE: EncoderFor<i32>, TEXT: EncoderFor<LString<'static>>, ANNOTATIONS: EncoderFor<Array<'static, i16, Annotation<'static>>>,

impl<SEVERITY, CODE, TEXT, ANNOTATIONS> EncoderFor<LogMessage<'static>> for LogMessageBuilder<SEVERITY, CODE, TEXT, ANNOTATIONS>

where SEVERITY: EncoderFor<u8>, CODE: EncoderFor<i32>, TEXT: EncoderFor<LString<'static>>, ANNOTATIONS: EncoderFor<Array<'static, i16, Annotation<'static>>>,

impl<SEVERITY, ERROR_CODE, MESSAGE, ATTRIBUTES> EncoderFor<ErrorResponse<'static>> for &ErrorResponseBuilder<SEVERITY, ERROR_CODE, MESSAGE, ATTRIBUTES>

where SEVERITY: EncoderFor<u8>, ERROR_CODE: EncoderFor<u32>, MESSAGE: EncoderFor<LString<'static>>, ATTRIBUTES: EncoderFor<Array<'static, i16, KeyValue<'static>>>,

impl<SEVERITY, ERROR_CODE, MESSAGE, ATTRIBUTES> EncoderFor<ErrorResponse<'static>> for ErrorResponseBuilder<SEVERITY, ERROR_CODE, MESSAGE, ATTRIBUTES>

where SEVERITY: EncoderFor<u8>, ERROR_CODE: EncoderFor<u32>, MESSAGE: EncoderFor<LString<'static>>, ATTRIBUTES: EncoderFor<Array<'static, i16, KeyValue<'static>>>,

impl<T> EncoderFor<Rest<'static>> for T

where T: AsRef<[u8]>,

impl<T> EncoderFor<RestArray<'static, T>> for RestArray<'static, T>

where T: DataType + EncoderFor<T> + DecoderFor<'static, T>,

Self encoder

impl<T> EncoderFor<ZTArray<'static, T>> for ZTArray<'static, T>

where T: DataType + EncoderFor<T> + DecoderFor<'static, T>,

Self encoder

impl<T, A> EncoderFor<ArrayString<'static, A>> for T

where &'any T: for<'any> AsRef<str>, A: AsRef<[u8]> + 'static, &'any [u8]: for<'any> EncoderFor<A>,

impl<T, F, I, II, IT> EncoderFor<RestArray<'static, T>> for F

where T: DataType + DecoderFor<'static, T>, F: Fn() -> I, I: IntoIterator<Item = IT, IntoIter = II>, IT: EncoderFor<T>, II: Iterator<Item = IT>,

Function encoder: see the note about about non-restartable iterators.

impl<T, F, I, II, IT> EncoderFor<ZTArray<'static, T>> for F

where T: DataType + DecoderFor<'static, T>, F: Fn() -> I, I: IntoIterator<Item = IT, IntoIter = II>, IT: EncoderFor<T>, II: Iterator<Item = IT>,

Function encoder: see the note about about non-restartable iterators.

impl<T, L> EncoderFor<Array<'static, L, T>> for Array<'static, L, T>

where T: DataType + EncoderFor<T> + DecoderFor<'static, T>, L: DataType + 'static,

Self encoder

impl<T, L, F, I, II, IT> EncoderFor<Array<'static, L, T>> for F

where T: DataType + DecoderFor<'static, T>, L: DataType + 'static, F: Fn() -> I, I: IntoIterator<Item = IT, IntoIter = II>, IT: EncoderFor<T>, II: ExactSizeIterator<Item = IT>,

Function encoder: see the note about about non-restartable iterators.

impl<T, U> EncoderFor<LengthPrefixed<T>> for LengthPrefixed<U>

where U: EncoderFor<T>, T: 'static,

impl<TYPEDESC_ID, TYPEDESC> EncoderFor<StateDataDescription<'static>> for &StateDataDescriptionBuilder<TYPEDESC_ID, TYPEDESC>

where TYPEDESC_ID: EncoderFor<Uuid>, TYPEDESC: EncoderFor<Array<'static, u32, u8>>,

impl<TYPEDESC_ID, TYPEDESC> EncoderFor<StateDataDescription<'static>> for StateDataDescriptionBuilder<TYPEDESC_ID, TYPEDESC>

where TYPEDESC_ID: EncoderFor<Uuid>, TYPEDESC: EncoderFor<Array<'static, u32, u8>>,

impl<TYPE_NAME, TYPE_CLASS, TYPE_ID> EncoderFor<DumpTypeInfo<'static>> for &DumpTypeInfoBuilder<TYPE_NAME, TYPE_CLASS, TYPE_ID>

where TYPE_NAME: EncoderFor<LString<'static>>, TYPE_CLASS: EncoderFor<LString<'static>>, TYPE_ID: EncoderFor<Uuid>,

impl<TYPE_NAME, TYPE_CLASS, TYPE_ID> EncoderFor<DumpTypeInfo<'static>> for DumpTypeInfoBuilder<TYPE_NAME, TYPE_CLASS, TYPE_ID>

where TYPE_NAME: EncoderFor<LString<'static>>, TYPE_CLASS: EncoderFor<LString<'static>>, TYPE_ID: EncoderFor<Uuid>,