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<CloseType> for &CloseType

impl EncoderFor<CloseType> for CloseType

impl EncoderFor<CopyFormat> for &CopyFormat

impl EncoderFor<CopyFormat> for CopyFormat

impl EncoderFor<DescribeType> for &DescribeType

impl EncoderFor<DescribeType> for DescribeType

impl EncoderFor<FormatCode> for &FormatCode

impl EncoderFor<FormatCode> for FormatCode

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

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

impl EncoderFor<AuthenticationCleartextPassword<'static>> for &AuthenticationCleartextPasswordBuilder

impl EncoderFor<AuthenticationCleartextPassword<'static>> for AuthenticationCleartextPasswordBuilder

impl EncoderFor<AuthenticationGSS<'static>> for &AuthenticationGSSBuilder

impl EncoderFor<AuthenticationGSS<'static>> for AuthenticationGSSBuilder

impl EncoderFor<AuthenticationKerberosV5<'static>> for &AuthenticationKerberosV5Builder

impl EncoderFor<AuthenticationKerberosV5<'static>> for AuthenticationKerberosV5Builder

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

impl EncoderFor<AuthenticationOk<'static>> for AuthenticationOkBuilder

impl EncoderFor<AuthenticationSCMCredential<'static>> for &AuthenticationSCMCredentialBuilder

impl EncoderFor<AuthenticationSCMCredential<'static>> for AuthenticationSCMCredentialBuilder

impl EncoderFor<AuthenticationSSPI<'static>> for &AuthenticationSSPIBuilder

impl EncoderFor<AuthenticationSSPI<'static>> for AuthenticationSSPIBuilder

impl EncoderFor<BindComplete<'static>> for &BindCompleteBuilder

impl EncoderFor<BindComplete<'static>> for BindCompleteBuilder

impl EncoderFor<CloseComplete<'static>> for &CloseCompleteBuilder

impl EncoderFor<CloseComplete<'static>> for CloseCompleteBuilder

impl EncoderFor<CopyDone<'static>> for &CopyDoneBuilder

impl EncoderFor<CopyDone<'static>> for CopyDoneBuilder

impl EncoderFor<EmptyQueryResponse<'static>> for &EmptyQueryResponseBuilder

impl EncoderFor<EmptyQueryResponse<'static>> for EmptyQueryResponseBuilder

impl EncoderFor<Flush<'static>> for &FlushBuilder

impl EncoderFor<Flush<'static>> for FlushBuilder

impl EncoderFor<GSSENCRequest<'static>> for &GSSENCRequestBuilder

impl EncoderFor<GSSENCRequest<'static>> for GSSENCRequestBuilder

impl EncoderFor<NoData<'static>> for &NoDataBuilder

impl EncoderFor<NoData<'static>> for NoDataBuilder

impl EncoderFor<ParseComplete<'static>> for &ParseCompleteBuilder

impl EncoderFor<ParseComplete<'static>> for ParseCompleteBuilder

impl EncoderFor<PortalSuspended<'static>> for &PortalSuspendedBuilder

impl EncoderFor<PortalSuspended<'static>> for PortalSuspendedBuilder

impl EncoderFor<SSLRequest<'static>> for &SSLRequestBuilder

impl EncoderFor<SSLRequest<'static>> for SSLRequestBuilder

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 EncoderFor<Length> for Length

impl EncoderFor<Uuid> for &Uuid

impl EncoderFor<Uuid> for Uuid

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<CODE> EncoderFor<SSLResponse<'static>> for &SSLResponseBuilder<CODE>

where CODE: EncoderFor<u8>,

impl<CODE> EncoderFor<SSLResponse<'static>> for SSLResponseBuilder<CODE>

where CODE: EncoderFor<u8>,

impl<CTYPE, NAME> EncoderFor<Close<'static>> for &CloseBuilder<CTYPE, NAME>

where CTYPE: EncoderFor<CloseType>, NAME: EncoderFor<ZTString<'static>>,

impl<CTYPE, NAME> EncoderFor<Close<'static>> for CloseBuilder<CTYPE, NAME>

where CTYPE: EncoderFor<CloseType>, NAME: EncoderFor<ZTString<'static>>,

impl<DATA> EncoderFor<AuthenticationGSSContinue<'static>> for &AuthenticationGSSContinueBuilder<DATA>

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

impl<DATA> EncoderFor<AuthenticationGSSContinue<'static>> for AuthenticationGSSContinueBuilder<DATA>

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

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

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

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

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

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

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

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

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

impl<DATA> EncoderFor<CopyData<'static>> for &CopyDataBuilder<DATA>

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

impl<DATA> EncoderFor<CopyData<'static>> for CopyDataBuilder<DATA>

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

impl<DATA> EncoderFor<GSSResponse<'static>> for &GSSResponseBuilder<DATA>

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

impl<DATA> EncoderFor<GSSResponse<'static>> for GSSResponseBuilder<DATA>

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

impl<DTYPE, NAME> EncoderFor<Describe<'static>> for &DescribeBuilder<DTYPE, NAME>

where DTYPE: EncoderFor<DescribeType>, NAME: EncoderFor<ZTString<'static>>,

impl<DTYPE, NAME> EncoderFor<Describe<'static>> for DescribeBuilder<DTYPE, NAME>

where DTYPE: EncoderFor<DescribeType>, NAME: EncoderFor<ZTString<'static>>,

impl<ERROR_MSG> EncoderFor<CopyFail<'static>> for &CopyFailBuilder<ERROR_MSG>

where ERROR_MSG: EncoderFor<ZTString<'static>>,

impl<ERROR_MSG> EncoderFor<CopyFail<'static>> for CopyFailBuilder<ERROR_MSG>

where ERROR_MSG: EncoderFor<ZTString<'static>>,

impl<ETYPE, VALUE> EncoderFor<ErrorField<'static>> for &ErrorFieldBuilder<ETYPE, VALUE>

where ETYPE: EncoderFor<u8>, VALUE: EncoderFor<ZTString<'static>>,

impl<ETYPE, VALUE> EncoderFor<ErrorField<'static>> for ErrorFieldBuilder<ETYPE, VALUE>

where ETYPE: EncoderFor<u8>, VALUE: EncoderFor<ZTString<'static>>,

impl<FIELDS> EncoderFor<ErrorResponse<'static>> for &ErrorResponseBuilder<FIELDS>

where FIELDS: EncoderFor<ZTArray<'static, ErrorField<'static>>>,

impl<FIELDS> EncoderFor<ErrorResponse<'static>> for ErrorResponseBuilder<FIELDS>

where FIELDS: EncoderFor<ZTArray<'static, ErrorField<'static>>>,

impl<FIELDS> EncoderFor<NoticeResponse<'static>> for &NoticeResponseBuilder<FIELDS>

where FIELDS: EncoderFor<ZTArray<'static, NoticeField<'static>>>,

impl<FIELDS> EncoderFor<NoticeResponse<'static>> for NoticeResponseBuilder<FIELDS>

where FIELDS: EncoderFor<ZTArray<'static, NoticeField<'static>>>,

impl<FIELDS> EncoderFor<RowDescription<'static>> for &RowDescriptionBuilder<FIELDS>

where FIELDS: EncoderFor<Array<'static, i16, RowField<'static>>>,

impl<FIELDS> EncoderFor<RowDescription<'static>> for RowDescriptionBuilder<FIELDS>

where FIELDS: EncoderFor<Array<'static, i16, RowField<'static>>>,

impl<FORMAT, FORMAT_CODES> EncoderFor<CopyBothResponse<'static>> for &CopyBothResponseBuilder<FORMAT, FORMAT_CODES>

where FORMAT: EncoderFor<CopyFormat>, FORMAT_CODES: EncoderFor<Array<'static, i16, i16>>,

impl<FORMAT, FORMAT_CODES> EncoderFor<CopyBothResponse<'static>> for CopyBothResponseBuilder<FORMAT, FORMAT_CODES>

where FORMAT: EncoderFor<CopyFormat>, FORMAT_CODES: EncoderFor<Array<'static, i16, i16>>,

impl<FORMAT, FORMAT_CODES> EncoderFor<CopyInResponse<'static>> for &CopyInResponseBuilder<FORMAT, FORMAT_CODES>

where FORMAT: EncoderFor<CopyFormat>, FORMAT_CODES: EncoderFor<Array<'static, i16, i16>>,

impl<FORMAT, FORMAT_CODES> EncoderFor<CopyInResponse<'static>> for CopyInResponseBuilder<FORMAT, FORMAT_CODES>

where FORMAT: EncoderFor<CopyFormat>, FORMAT_CODES: EncoderFor<Array<'static, i16, i16>>,

impl<FORMAT, FORMAT_CODES> EncoderFor<CopyOutResponse<'static>> for &CopyOutResponseBuilder<FORMAT, FORMAT_CODES>

where FORMAT: EncoderFor<CopyFormat>, FORMAT_CODES: EncoderFor<Array<'static, i16, i16>>,

impl<FORMAT, FORMAT_CODES> EncoderFor<CopyOutResponse<'static>> for CopyOutResponseBuilder<FORMAT, FORMAT_CODES>

where FORMAT: EncoderFor<CopyFormat>, FORMAT_CODES: EncoderFor<Array<'static, i16, i16>>,

impl<FUNCTION_ID, FORMAT_CODES, ARGS, RESULT_FORMAT_CODE> EncoderFor<FunctionCall<'static>> for &FunctionCallBuilder<FUNCTION_ID, FORMAT_CODES, ARGS, RESULT_FORMAT_CODE>

where FUNCTION_ID: EncoderFor<i32>, FORMAT_CODES: EncoderFor<Array<'static, i16, FormatCode>>, ARGS: EncoderFor<Array<'static, i16, Encoded<'static>>>, RESULT_FORMAT_CODE: EncoderFor<FormatCode>,

impl<FUNCTION_ID, FORMAT_CODES, ARGS, RESULT_FORMAT_CODE> EncoderFor<FunctionCall<'static>> for FunctionCallBuilder<FUNCTION_ID, FORMAT_CODES, ARGS, RESULT_FORMAT_CODE>

where FUNCTION_ID: EncoderFor<i32>, FORMAT_CODES: EncoderFor<Array<'static, i16, FormatCode>>, ARGS: EncoderFor<Array<'static, i16, Encoded<'static>>>, RESULT_FORMAT_CODE: EncoderFor<FormatCode>,

impl<MECHANISM, RESPONSE> EncoderFor<SASLInitialResponse<'static>> for &SASLInitialResponseBuilder<MECHANISM, RESPONSE>

where MECHANISM: EncoderFor<ZTString<'static>>, RESPONSE: EncoderFor<Array<'static, i32, u8>>,

impl<MECHANISM, RESPONSE> EncoderFor<SASLInitialResponse<'static>> for SASLInitialResponseBuilder<MECHANISM, RESPONSE>

where MECHANISM: EncoderFor<ZTString<'static>>, RESPONSE: EncoderFor<Array<'static, i32, u8>>,

impl<MECHANISMS> EncoderFor<AuthenticationSASL<'static>> for &AuthenticationSASLBuilder<MECHANISMS>

where MECHANISMS: EncoderFor<ZTArray<'static, ZTString<'static>>>,

impl<MECHANISMS> EncoderFor<AuthenticationSASL<'static>> for AuthenticationSASLBuilder<MECHANISMS>

where MECHANISMS: EncoderFor<ZTArray<'static, ZTString<'static>>>,

impl<MINOR_VERSION, OPTIONS> EncoderFor<NegotiateProtocolVersion<'static>> for &NegotiateProtocolVersionBuilder<MINOR_VERSION, OPTIONS>

where MINOR_VERSION: EncoderFor<i32>, OPTIONS: EncoderFor<Array<'static, i32, ZTString<'static>>>,

impl<MINOR_VERSION, OPTIONS> EncoderFor<NegotiateProtocolVersion<'static>> for NegotiateProtocolVersionBuilder<MINOR_VERSION, OPTIONS>

where MINOR_VERSION: EncoderFor<i32>, OPTIONS: EncoderFor<Array<'static, i32, ZTString<'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, TABLE_OID, COLUMN_ATTR_NUMBER, DATA_TYPE_OID, DATA_TYPE_SIZE, TYPE_MODIFIER, FORMAT_CODE> EncoderFor<RowField<'static>> for &RowFieldBuilder<NAME, TABLE_OID, COLUMN_ATTR_NUMBER, DATA_TYPE_OID, DATA_TYPE_SIZE, TYPE_MODIFIER, FORMAT_CODE>

where NAME: EncoderFor<ZTString<'static>>, TABLE_OID: EncoderFor<i32>, COLUMN_ATTR_NUMBER: EncoderFor<i16>, DATA_TYPE_OID: EncoderFor<i32>, DATA_TYPE_SIZE: EncoderFor<i16>, TYPE_MODIFIER: EncoderFor<i32>, FORMAT_CODE: EncoderFor<FormatCode>,

impl<NAME, TABLE_OID, COLUMN_ATTR_NUMBER, DATA_TYPE_OID, DATA_TYPE_SIZE, TYPE_MODIFIER, FORMAT_CODE> EncoderFor<RowField<'static>> for RowFieldBuilder<NAME, TABLE_OID, COLUMN_ATTR_NUMBER, DATA_TYPE_OID, DATA_TYPE_SIZE, TYPE_MODIFIER, FORMAT_CODE>

where NAME: EncoderFor<ZTString<'static>>, TABLE_OID: EncoderFor<i32>, COLUMN_ATTR_NUMBER: EncoderFor<i16>, DATA_TYPE_OID: EncoderFor<i32>, DATA_TYPE_SIZE: EncoderFor<i16>, TYPE_MODIFIER: EncoderFor<i32>, FORMAT_CODE: EncoderFor<FormatCode>,

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

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

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

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

impl<NAME, VALUE> EncoderFor<StartupNameValue<'static>> for &StartupNameValueBuilder<NAME, VALUE>

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

impl<NAME, VALUE> EncoderFor<StartupNameValue<'static>> for StartupNameValueBuilder<NAME, VALUE>

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

impl<NTYPE, VALUE> EncoderFor<NoticeField<'static>> for &NoticeFieldBuilder<NTYPE, VALUE>

where NTYPE: EncoderFor<u8>, VALUE: EncoderFor<ZTString<'static>>,

impl<NTYPE, VALUE> EncoderFor<NoticeField<'static>> for NoticeFieldBuilder<NTYPE, VALUE>

where NTYPE: EncoderFor<u8>, VALUE: EncoderFor<ZTString<'static>>,

impl<PARAMS> EncoderFor<StartupMessage<'static>> for &StartupMessageBuilder<PARAMS>

where PARAMS: EncoderFor<ZTArray<'static, StartupNameValue<'static>>>,

impl<PARAMS> EncoderFor<StartupMessage<'static>> for StartupMessageBuilder<PARAMS>

where PARAMS: EncoderFor<ZTArray<'static, StartupNameValue<'static>>>,

impl<PARAM_TYPES> EncoderFor<ParameterDescription<'static>> for &ParameterDescriptionBuilder<PARAM_TYPES>

where PARAM_TYPES: EncoderFor<Array<'static, i16, i32>>,

impl<PARAM_TYPES> EncoderFor<ParameterDescription<'static>> for ParameterDescriptionBuilder<PARAM_TYPES>

where PARAM_TYPES: EncoderFor<Array<'static, i16, i32>>,

impl<PASSWORD> EncoderFor<PasswordMessage<'static>> for &PasswordMessageBuilder<PASSWORD>

where PASSWORD: EncoderFor<ZTString<'static>>,

impl<PASSWORD> EncoderFor<PasswordMessage<'static>> for PasswordMessageBuilder<PASSWORD>

where PASSWORD: EncoderFor<ZTString<'static>>,

impl<PID, CHANNEL, PAYLOAD> EncoderFor<NotificationResponse<'static>> for &NotificationResponseBuilder<PID, CHANNEL, PAYLOAD>

where PID: EncoderFor<i32>, CHANNEL: EncoderFor<ZTString<'static>>, PAYLOAD: EncoderFor<ZTString<'static>>,

impl<PID, CHANNEL, PAYLOAD> EncoderFor<NotificationResponse<'static>> for NotificationResponseBuilder<PID, CHANNEL, PAYLOAD>

where PID: EncoderFor<i32>, CHANNEL: EncoderFor<ZTString<'static>>, PAYLOAD: EncoderFor<ZTString<'static>>,

impl<PID, KEY> EncoderFor<BackendKeyData<'static>> for &BackendKeyDataBuilder<PID, KEY>

where PID: EncoderFor<i32>, KEY: EncoderFor<i32>,

impl<PID, KEY> EncoderFor<BackendKeyData<'static>> for BackendKeyDataBuilder<PID, KEY>

where PID: EncoderFor<i32>, KEY: EncoderFor<i32>,

impl<PID, KEY> EncoderFor<CancelRequest<'static>> for &CancelRequestBuilder<PID, KEY>

where PID: EncoderFor<i32>, KEY: EncoderFor<i32>,

impl<PID, KEY> EncoderFor<CancelRequest<'static>> for CancelRequestBuilder<PID, KEY>

where PID: EncoderFor<i32>, KEY: EncoderFor<i32>,

impl<PORTAL, MAX_ROWS> EncoderFor<Execute<'static>> for &ExecuteBuilder<PORTAL, MAX_ROWS>

where PORTAL: EncoderFor<ZTString<'static>>, MAX_ROWS: EncoderFor<i32>,

impl<PORTAL, MAX_ROWS> EncoderFor<Execute<'static>> for ExecuteBuilder<PORTAL, MAX_ROWS>

where PORTAL: EncoderFor<ZTString<'static>>, MAX_ROWS: EncoderFor<i32>,

impl<PORTAL, STATEMENT, FORMAT_CODES, VALUES, RESULT_FORMAT_CODES> EncoderFor<Bind<'static>> for &BindBuilder<PORTAL, STATEMENT, FORMAT_CODES, VALUES, RESULT_FORMAT_CODES>

where PORTAL: EncoderFor<ZTString<'static>>, STATEMENT: EncoderFor<ZTString<'static>>, FORMAT_CODES: EncoderFor<Array<'static, i16, i16>>, VALUES: EncoderFor<Array<'static, i16, Encoded<'static>>>, RESULT_FORMAT_CODES: EncoderFor<Array<'static, i16, i16>>,

impl<PORTAL, STATEMENT, FORMAT_CODES, VALUES, RESULT_FORMAT_CODES> EncoderFor<Bind<'static>> for BindBuilder<PORTAL, STATEMENT, FORMAT_CODES, VALUES, RESULT_FORMAT_CODES>

where PORTAL: EncoderFor<ZTString<'static>>, STATEMENT: EncoderFor<ZTString<'static>>, FORMAT_CODES: EncoderFor<Array<'static, i16, i16>>, VALUES: EncoderFor<Array<'static, i16, Encoded<'static>>>, RESULT_FORMAT_CODES: EncoderFor<Array<'static, i16, i16>>,

impl<PROTOCOL_VERSION, DATA> EncoderFor<InitialMessage<'static>> for &InitialMessageBuilder<PROTOCOL_VERSION, DATA>

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

impl<PROTOCOL_VERSION, DATA> EncoderFor<InitialMessage<'static>> for InitialMessageBuilder<PROTOCOL_VERSION, DATA>

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

impl<QUERY> EncoderFor<Query<'static>> for &QueryBuilder<QUERY>

where QUERY: EncoderFor<ZTString<'static>>,

impl<QUERY> EncoderFor<Query<'static>> for QueryBuilder<QUERY>

where QUERY: EncoderFor<ZTString<'static>>,

impl<RESPONSE> EncoderFor<SASLResponse<'static>> for &SASLResponseBuilder<RESPONSE>

where RESPONSE: EncoderFor<Rest<'static>>,

impl<RESPONSE> EncoderFor<SASLResponse<'static>> for SASLResponseBuilder<RESPONSE>

where RESPONSE: EncoderFor<Rest<'static>>,

impl<RESULT> EncoderFor<FunctionCallResponse<'static>> for &FunctionCallResponseBuilder<RESULT>

where RESULT: EncoderFor<Encoded<'static>>,

impl<RESULT> EncoderFor<FunctionCallResponse<'static>> for FunctionCallResponseBuilder<RESULT>

where RESULT: EncoderFor<Encoded<'static>>,

impl<SALT> EncoderFor<AuthenticationMD5Password<'static>> for &AuthenticationMD5PasswordBuilder<SALT>

where SALT: EncoderFor<[u8; 4]>,

impl<SALT> EncoderFor<AuthenticationMD5Password<'static>> for AuthenticationMD5PasswordBuilder<SALT>

where SALT: EncoderFor<[u8; 4]>,

impl<STATEMENT, QUERY, PARAM_TYPES> EncoderFor<Parse<'static>> for &ParseBuilder<STATEMENT, QUERY, PARAM_TYPES>

where STATEMENT: EncoderFor<ZTString<'static>>, QUERY: EncoderFor<ZTString<'static>>, PARAM_TYPES: EncoderFor<Array<'static, i16, i32>>,

impl<STATEMENT, QUERY, PARAM_TYPES> EncoderFor<Parse<'static>> for ParseBuilder<STATEMENT, QUERY, PARAM_TYPES>

where STATEMENT: EncoderFor<ZTString<'static>>, QUERY: EncoderFor<ZTString<'static>>, PARAM_TYPES: EncoderFor<Array<'static, i16, i32>>,

impl<STATUS> EncoderFor<AuthenticationMessage<'static>> for &AuthenticationMessageBuilder<STATUS>

where STATUS: EncoderFor<i32>,

impl<STATUS> EncoderFor<AuthenticationMessage<'static>> for AuthenticationMessageBuilder<STATUS>

where STATUS: EncoderFor<i32>,

impl<STATUS> EncoderFor<ReadyForQuery<'static>> for &ReadyForQueryBuilder<STATUS>

where STATUS: EncoderFor<u8>,

impl<STATUS> EncoderFor<ReadyForQuery<'static>> for ReadyForQueryBuilder<STATUS>

where STATUS: EncoderFor<u8>,

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<TAG> EncoderFor<CommandComplete<'static>> for &CommandCompleteBuilder<TAG>

where TAG: EncoderFor<ZTString<'static>>,

impl<TAG> EncoderFor<CommandComplete<'static>> for CommandCompleteBuilder<TAG>

where TAG: EncoderFor<ZTString<'static>>,

impl<VALUES> EncoderFor<DataRow<'static>> for &DataRowBuilder<VALUES>

where VALUES: EncoderFor<Array<'static, i16, Encoded<'static>>>,

impl<VALUES> EncoderFor<DataRow<'static>> for DataRowBuilder<VALUES>

where VALUES: EncoderFor<Array<'static, i16, Encoded<'static>>>,