Trait DecoderFor

pub trait DecoderFor<'a, F>: DataType + 'a
where
    F: 'a,
{
    // Required method
    fn decode_for(buf: &mut &'a [u8]) -> Result<F, ParseError>;
}

Marks a type as a decoder for itself.

Required Methods

fn decode_for(buf: &mut &'a [u8]) -> Result<F, ParseError>

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl<'a> DecoderFor<'a, f32> for f32

fn decode_for(buf: &mut &'a [u8]) -> Result<f32, ParseError>

impl<'a> DecoderFor<'a, f64> for f64

fn decode_for(buf: &mut &'a [u8]) -> Result<f64, ParseError>

impl<'a> DecoderFor<'a, i8> for i8

fn decode_for(buf: &mut &'a [u8]) -> Result<i8, ParseError>

impl<'a> DecoderFor<'a, i16> for i16

fn decode_for(buf: &mut &'a [u8]) -> Result<i16, ParseError>

impl<'a> DecoderFor<'a, i32> for i32

fn decode_for(buf: &mut &'a [u8]) -> Result<i32, ParseError>

impl<'a> DecoderFor<'a, i64> for i64

fn decode_for(buf: &mut &'a [u8]) -> Result<i64, ParseError>

impl<'a> DecoderFor<'a, i128> for i128

fn decode_for(buf: &mut &'a [u8]) -> Result<i128, ParseError>

impl<'a> DecoderFor<'a, u8> for u8

fn decode_for(buf: &mut &'a [u8]) -> Result<u8, ParseError>

impl<'a> DecoderFor<'a, u16> for u16

fn decode_for(buf: &mut &'a [u8]) -> Result<u16, ParseError>

impl<'a> DecoderFor<'a, u32> for u32

fn decode_for(buf: &mut &'a [u8]) -> Result<u32, ParseError>

impl<'a> DecoderFor<'a, u64> for u64

fn decode_for(buf: &mut &'a [u8]) -> Result<u64, ParseError>

impl<'a> DecoderFor<'a, u128> for u128

fn decode_for(buf: &mut &'a [u8]) -> Result<u128, ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 A: DataType + DecoderFor<'a, A>, B: DataType + DecoderFor<'a, B>, C: DataType + DecoderFor<'a, C>, D: DataType + DecoderFor<'a, D>, E: DataType + DecoderFor<'a, E>, F: DataType + DecoderFor<'a, F>, G: DataType + DecoderFor<'a, G>, H: DataType + DecoderFor<'a, H>, I: DataType + DecoderFor<'a, I>, J: DataType + DecoderFor<'a, J>, K: DataType + DecoderFor<'a, K>, L: DataType + DecoderFor<'a, L>, M: DataType + DecoderFor<'a, M>, N: DataType + DecoderFor<'a, N>, O: DataType + DecoderFor<'a, O>, P: DataType + DecoderFor<'a, P>, Q: DataType + DecoderFor<'a, Q>, R: DataType + DecoderFor<'a, R>, S: DataType + DecoderFor<'a, S>, T: DataType + DecoderFor<'a, T>, U: DataType + DecoderFor<'a, U>, V: DataType + DecoderFor<'a, V>, W: DataType + DecoderFor<'a, W>, X: DataType + DecoderFor<'a, X>, Y: DataType + DecoderFor<'a, Y>, Z: DataType + DecoderFor<'a, Z>, A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'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> DecoderFor<'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)> 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 B: DataType + DecoderFor<'a, B>, C: DataType + DecoderFor<'a, C>, D: DataType + DecoderFor<'a, D>, E: DataType + DecoderFor<'a, E>, F: DataType + DecoderFor<'a, F>, G: DataType + DecoderFor<'a, G>, H: DataType + DecoderFor<'a, H>, I: DataType + DecoderFor<'a, I>, J: DataType + DecoderFor<'a, J>, K: DataType + DecoderFor<'a, K>, L: DataType + DecoderFor<'a, L>, M: DataType + DecoderFor<'a, M>, N: DataType + DecoderFor<'a, N>, O: DataType + DecoderFor<'a, O>, P: DataType + DecoderFor<'a, P>, Q: DataType + DecoderFor<'a, Q>, R: DataType + DecoderFor<'a, R>, S: DataType + DecoderFor<'a, S>, T: DataType + DecoderFor<'a, T>, U: DataType + DecoderFor<'a, U>, V: DataType + DecoderFor<'a, V>, W: DataType + DecoderFor<'a, W>, X: DataType + DecoderFor<'a, X>, Y: DataType + DecoderFor<'a, Y>, Z: DataType + DecoderFor<'a, Z>, A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'a, C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1> DecoderFor<'a, (C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)> 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 C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(C1, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1), ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 C: DataType + DecoderFor<'a, C>, D: DataType + DecoderFor<'a, D>, E: DataType + DecoderFor<'a, E>, F: DataType + DecoderFor<'a, F>, G: DataType + DecoderFor<'a, G>, H: DataType + DecoderFor<'a, H>, I: DataType + DecoderFor<'a, I>, J: DataType + DecoderFor<'a, J>, K: DataType + DecoderFor<'a, K>, L: DataType + DecoderFor<'a, L>, M: DataType + DecoderFor<'a, M>, N: DataType + DecoderFor<'a, N>, O: DataType + DecoderFor<'a, O>, P: DataType + DecoderFor<'a, P>, Q: DataType + DecoderFor<'a, Q>, R: DataType + DecoderFor<'a, R>, S: DataType + DecoderFor<'a, S>, T: DataType + DecoderFor<'a, T>, U: DataType + DecoderFor<'a, U>, V: DataType + DecoderFor<'a, V>, W: DataType + DecoderFor<'a, W>, X: DataType + DecoderFor<'a, X>, Y: DataType + DecoderFor<'a, Y>, Z: DataType + DecoderFor<'a, Z>, A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'a, D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1> DecoderFor<'a, (D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)> 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 D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(D1, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1), ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 D: DataType + DecoderFor<'a, D>, E: DataType + DecoderFor<'a, E>, F: DataType + DecoderFor<'a, F>, G: DataType + DecoderFor<'a, G>, H: DataType + DecoderFor<'a, H>, I: DataType + DecoderFor<'a, I>, J: DataType + DecoderFor<'a, J>, K: DataType + DecoderFor<'a, K>, L: DataType + DecoderFor<'a, L>, M: DataType + DecoderFor<'a, M>, N: DataType + DecoderFor<'a, N>, O: DataType + DecoderFor<'a, O>, P: DataType + DecoderFor<'a, P>, Q: DataType + DecoderFor<'a, Q>, R: DataType + DecoderFor<'a, R>, S: DataType + DecoderFor<'a, S>, T: DataType + DecoderFor<'a, T>, U: DataType + DecoderFor<'a, U>, V: DataType + DecoderFor<'a, V>, W: DataType + DecoderFor<'a, W>, X: DataType + DecoderFor<'a, X>, Y: DataType + DecoderFor<'a, Y>, Z: DataType + DecoderFor<'a, Z>, A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'a, E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1> DecoderFor<'a, (E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)> for (E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(E1, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1), ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 E: DataType + DecoderFor<'a, E>, F: DataType + DecoderFor<'a, F>, G: DataType + DecoderFor<'a, G>, H: DataType + DecoderFor<'a, H>, I: DataType + DecoderFor<'a, I>, J: DataType + DecoderFor<'a, J>, K: DataType + DecoderFor<'a, K>, L: DataType + DecoderFor<'a, L>, M: DataType + DecoderFor<'a, M>, N: DataType + DecoderFor<'a, N>, O: DataType + DecoderFor<'a, O>, P: DataType + DecoderFor<'a, P>, Q: DataType + DecoderFor<'a, Q>, R: DataType + DecoderFor<'a, R>, S: DataType + DecoderFor<'a, S>, T: DataType + DecoderFor<'a, T>, U: DataType + DecoderFor<'a, U>, V: DataType + DecoderFor<'a, V>, W: DataType + DecoderFor<'a, W>, X: DataType + DecoderFor<'a, X>, Y: DataType + DecoderFor<'a, Y>, Z: DataType + DecoderFor<'a, Z>, A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'a, F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1> DecoderFor<'a, (F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)> for (F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(F1, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1), ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 F: DataType + DecoderFor<'a, F>, G: DataType + DecoderFor<'a, G>, H: DataType + DecoderFor<'a, H>, I: DataType + DecoderFor<'a, I>, J: DataType + DecoderFor<'a, J>, K: DataType + DecoderFor<'a, K>, L: DataType + DecoderFor<'a, L>, M: DataType + DecoderFor<'a, M>, N: DataType + DecoderFor<'a, N>, O: DataType + DecoderFor<'a, O>, P: DataType + DecoderFor<'a, P>, Q: DataType + DecoderFor<'a, Q>, R: DataType + DecoderFor<'a, R>, S: DataType + DecoderFor<'a, S>, T: DataType + DecoderFor<'a, T>, U: DataType + DecoderFor<'a, U>, V: DataType + DecoderFor<'a, V>, W: DataType + DecoderFor<'a, W>, X: DataType + DecoderFor<'a, X>, Y: DataType + DecoderFor<'a, Y>, Z: DataType + DecoderFor<'a, Z>, A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'a, G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1> DecoderFor<'a, (G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)> for (G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(G1, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1), ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 G: DataType + DecoderFor<'a, G>, H: DataType + DecoderFor<'a, H>, I: DataType + DecoderFor<'a, I>, J: DataType + DecoderFor<'a, J>, K: DataType + DecoderFor<'a, K>, L: DataType + DecoderFor<'a, L>, M: DataType + DecoderFor<'a, M>, N: DataType + DecoderFor<'a, N>, O: DataType + DecoderFor<'a, O>, P: DataType + DecoderFor<'a, P>, Q: DataType + DecoderFor<'a, Q>, R: DataType + DecoderFor<'a, R>, S: DataType + DecoderFor<'a, S>, T: DataType + DecoderFor<'a, T>, U: DataType + DecoderFor<'a, U>, V: DataType + DecoderFor<'a, V>, W: DataType + DecoderFor<'a, W>, X: DataType + DecoderFor<'a, X>, Y: DataType + DecoderFor<'a, Y>, Z: DataType + DecoderFor<'a, Z>, A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'a, H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1> DecoderFor<'a, (H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)> for (H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(H1, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1), ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 H: DataType + DecoderFor<'a, H>, I: DataType + DecoderFor<'a, I>, J: DataType + DecoderFor<'a, J>, K: DataType + DecoderFor<'a, K>, L: DataType + DecoderFor<'a, L>, M: DataType + DecoderFor<'a, M>, N: DataType + DecoderFor<'a, N>, O: DataType + DecoderFor<'a, O>, P: DataType + DecoderFor<'a, P>, Q: DataType + DecoderFor<'a, Q>, R: DataType + DecoderFor<'a, R>, S: DataType + DecoderFor<'a, S>, T: DataType + DecoderFor<'a, T>, U: DataType + DecoderFor<'a, U>, V: DataType + DecoderFor<'a, V>, W: DataType + DecoderFor<'a, W>, X: DataType + DecoderFor<'a, X>, Y: DataType + DecoderFor<'a, Y>, Z: DataType + DecoderFor<'a, Z>, A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'a, I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1> DecoderFor<'a, (I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)> for (I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(I1, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1), ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 I: DataType + DecoderFor<'a, I>, J: DataType + DecoderFor<'a, J>, K: DataType + DecoderFor<'a, K>, L: DataType + DecoderFor<'a, L>, M: DataType + DecoderFor<'a, M>, N: DataType + DecoderFor<'a, N>, O: DataType + DecoderFor<'a, O>, P: DataType + DecoderFor<'a, P>, Q: DataType + DecoderFor<'a, Q>, R: DataType + DecoderFor<'a, R>, S: DataType + DecoderFor<'a, S>, T: DataType + DecoderFor<'a, T>, U: DataType + DecoderFor<'a, U>, V: DataType + DecoderFor<'a, V>, W: DataType + DecoderFor<'a, W>, X: DataType + DecoderFor<'a, X>, Y: DataType + DecoderFor<'a, Y>, Z: DataType + DecoderFor<'a, Z>, A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'a, J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1> DecoderFor<'a, (J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)> for (J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(J1, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1), ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 J: DataType + DecoderFor<'a, J>, K: DataType + DecoderFor<'a, K>, L: DataType + DecoderFor<'a, L>, M: DataType + DecoderFor<'a, M>, N: DataType + DecoderFor<'a, N>, O: DataType + DecoderFor<'a, O>, P: DataType + DecoderFor<'a, P>, Q: DataType + DecoderFor<'a, Q>, R: DataType + DecoderFor<'a, R>, S: DataType + DecoderFor<'a, S>, T: DataType + DecoderFor<'a, T>, U: DataType + DecoderFor<'a, U>, V: DataType + DecoderFor<'a, V>, W: DataType + DecoderFor<'a, W>, X: DataType + DecoderFor<'a, X>, Y: DataType + DecoderFor<'a, Y>, Z: DataType + DecoderFor<'a, Z>, A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'a, K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1> DecoderFor<'a, (K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)> for (K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(K1, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1), ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 K: DataType + DecoderFor<'a, K>, L: DataType + DecoderFor<'a, L>, M: DataType + DecoderFor<'a, M>, N: DataType + DecoderFor<'a, N>, O: DataType + DecoderFor<'a, O>, P: DataType + DecoderFor<'a, P>, Q: DataType + DecoderFor<'a, Q>, R: DataType + DecoderFor<'a, R>, S: DataType + DecoderFor<'a, S>, T: DataType + DecoderFor<'a, T>, U: DataType + DecoderFor<'a, U>, V: DataType + DecoderFor<'a, V>, W: DataType + DecoderFor<'a, W>, X: DataType + DecoderFor<'a, X>, Y: DataType + DecoderFor<'a, Y>, Z: DataType + DecoderFor<'a, Z>, A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'a, L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1> DecoderFor<'a, (L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)> for (L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(L1, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1), ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 L: DataType + DecoderFor<'a, L>, M: DataType + DecoderFor<'a, M>, N: DataType + DecoderFor<'a, N>, O: DataType + DecoderFor<'a, O>, P: DataType + DecoderFor<'a, P>, Q: DataType + DecoderFor<'a, Q>, R: DataType + DecoderFor<'a, R>, S: DataType + DecoderFor<'a, S>, T: DataType + DecoderFor<'a, T>, U: DataType + DecoderFor<'a, U>, V: DataType + DecoderFor<'a, V>, W: DataType + DecoderFor<'a, W>, X: DataType + DecoderFor<'a, X>, Y: DataType + DecoderFor<'a, Y>, Z: DataType + DecoderFor<'a, Z>, A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'a, M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1> DecoderFor<'a, (M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)> for (M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(M1, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1), ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 M: DataType + DecoderFor<'a, M>, N: DataType + DecoderFor<'a, N>, O: DataType + DecoderFor<'a, O>, P: DataType + DecoderFor<'a, P>, Q: DataType + DecoderFor<'a, Q>, R: DataType + DecoderFor<'a, R>, S: DataType + DecoderFor<'a, S>, T: DataType + DecoderFor<'a, T>, U: DataType + DecoderFor<'a, U>, V: DataType + DecoderFor<'a, V>, W: DataType + DecoderFor<'a, W>, X: DataType + DecoderFor<'a, X>, Y: DataType + DecoderFor<'a, Y>, Z: DataType + DecoderFor<'a, Z>, A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'a, N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1> DecoderFor<'a, (N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)> for (N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(N1, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1), ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 N: DataType + DecoderFor<'a, N>, O: DataType + DecoderFor<'a, O>, P: DataType + DecoderFor<'a, P>, Q: DataType + DecoderFor<'a, Q>, R: DataType + DecoderFor<'a, R>, S: DataType + DecoderFor<'a, S>, T: DataType + DecoderFor<'a, T>, U: DataType + DecoderFor<'a, U>, V: DataType + DecoderFor<'a, V>, W: DataType + DecoderFor<'a, W>, X: DataType + DecoderFor<'a, X>, Y: DataType + DecoderFor<'a, Y>, Z: DataType + DecoderFor<'a, Z>, A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'a, O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1> DecoderFor<'a, (O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)> for (O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(O1, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1), ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 O: DataType + DecoderFor<'a, O>, P: DataType + DecoderFor<'a, P>, Q: DataType + DecoderFor<'a, Q>, R: DataType + DecoderFor<'a, R>, S: DataType + DecoderFor<'a, S>, T: DataType + DecoderFor<'a, T>, U: DataType + DecoderFor<'a, U>, V: DataType + DecoderFor<'a, V>, W: DataType + DecoderFor<'a, W>, X: DataType + DecoderFor<'a, X>, Y: DataType + DecoderFor<'a, Y>, Z: DataType + DecoderFor<'a, Z>, A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'a, P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1> DecoderFor<'a, (P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)> for (P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(P1, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1), ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 P: DataType + DecoderFor<'a, P>, Q: DataType + DecoderFor<'a, Q>, R: DataType + DecoderFor<'a, R>, S: DataType + DecoderFor<'a, S>, T: DataType + DecoderFor<'a, T>, U: DataType + DecoderFor<'a, U>, V: DataType + DecoderFor<'a, V>, W: DataType + DecoderFor<'a, W>, X: DataType + DecoderFor<'a, X>, Y: DataType + DecoderFor<'a, Y>, Z: DataType + DecoderFor<'a, Z>, A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'a, Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1> DecoderFor<'a, (Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)> for (Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(Q1, R1, S1, T1, U1, V1, W1, X1, Y1, Z1), ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 Q: DataType + DecoderFor<'a, Q>, R: DataType + DecoderFor<'a, R>, S: DataType + DecoderFor<'a, S>, T: DataType + DecoderFor<'a, T>, U: DataType + DecoderFor<'a, U>, V: DataType + DecoderFor<'a, V>, W: DataType + DecoderFor<'a, W>, X: DataType + DecoderFor<'a, X>, Y: DataType + DecoderFor<'a, Y>, Z: DataType + DecoderFor<'a, Z>, A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'a, R1, S1, T1, U1, V1, W1, X1, Y1, Z1> DecoderFor<'a, (R1, S1, T1, U1, V1, W1, X1, Y1, Z1)> for (R1, S1, T1, U1, V1, W1, X1, Y1, Z1)

where R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(R1, S1, T1, U1, V1, W1, X1, Y1, Z1), ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 R: DataType + DecoderFor<'a, R>, S: DataType + DecoderFor<'a, S>, T: DataType + DecoderFor<'a, T>, U: DataType + DecoderFor<'a, U>, V: DataType + DecoderFor<'a, V>, W: DataType + DecoderFor<'a, W>, X: DataType + DecoderFor<'a, X>, Y: DataType + DecoderFor<'a, Y>, Z: DataType + DecoderFor<'a, Z>, A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'a, S1, T1, U1, V1, W1, X1, Y1, Z1> DecoderFor<'a, (S1, T1, U1, V1, W1, X1, Y1, Z1)> for (S1, T1, U1, V1, W1, X1, Y1, Z1)

where S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(S1, T1, U1, V1, W1, X1, Y1, Z1), ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 S: DataType + DecoderFor<'a, S>, T: DataType + DecoderFor<'a, T>, U: DataType + DecoderFor<'a, U>, V: DataType + DecoderFor<'a, V>, W: DataType + DecoderFor<'a, W>, X: DataType + DecoderFor<'a, X>, Y: DataType + DecoderFor<'a, Y>, Z: DataType + DecoderFor<'a, Z>, A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'a, T1, U1, V1, W1, X1, Y1, Z1> DecoderFor<'a, (T1, U1, V1, W1, X1, Y1, Z1)> for (T1, U1, V1, W1, X1, Y1, Z1)

where T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(T1, U1, V1, W1, X1, Y1, Z1), ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 T: DataType + DecoderFor<'a, T>, U: DataType + DecoderFor<'a, U>, V: DataType + DecoderFor<'a, V>, W: DataType + DecoderFor<'a, W>, X: DataType + DecoderFor<'a, X>, Y: DataType + DecoderFor<'a, Y>, Z: DataType + DecoderFor<'a, Z>, A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'a, T, const N: usize> DecoderFor<'a, [T; N]> for [T; N]

where T: DataType + DecoderFor<'a, T> + Default + Copy,

fn decode_for(buf: &mut &'a [u8]) -> Result<[T; N], ParseError>

impl<'a, U1, V1, W1, X1, Y1, Z1> DecoderFor<'a, (U1, V1, W1, X1, Y1, Z1)> for (U1, V1, W1, X1, Y1, Z1)

where U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(U1, V1, W1, X1, Y1, Z1), ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 U: DataType + DecoderFor<'a, U>, V: DataType + DecoderFor<'a, V>, W: DataType + DecoderFor<'a, W>, X: DataType + DecoderFor<'a, X>, Y: DataType + DecoderFor<'a, Y>, Z: DataType + DecoderFor<'a, Z>, A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'a, V1, W1, X1, Y1, Z1> DecoderFor<'a, (V1, W1, X1, Y1, Z1)> for (V1, W1, X1, Y1, Z1)

where V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for(buf: &mut &'a [u8]) -> Result<(V1, W1, X1, Y1, Z1), ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 V: DataType + DecoderFor<'a, V>, W: DataType + DecoderFor<'a, W>, X: DataType + DecoderFor<'a, X>, Y: DataType + DecoderFor<'a, Y>, Z: DataType + DecoderFor<'a, Z>, A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'a, W1, X1, Y1, Z1> DecoderFor<'a, (W1, X1, Y1, Z1)> for (W1, X1, Y1, Z1)

where W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for(buf: &mut &'a [u8]) -> Result<(W1, X1, Y1, Z1), ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 W: DataType + DecoderFor<'a, W>, X: DataType + DecoderFor<'a, X>, Y: DataType + DecoderFor<'a, Y>, Z: DataType + DecoderFor<'a, Z>, A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'a, X1, Y1, Z1> DecoderFor<'a, (X1, Y1, Z1)> for (X1, Y1, Z1)

where X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for(buf: &mut &'a [u8]) -> Result<(X1, Y1, Z1), ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 X: DataType + DecoderFor<'a, X>, Y: DataType + DecoderFor<'a, Y>, Z: DataType + DecoderFor<'a, Z>, A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'a, Y1, Z1> DecoderFor<'a, (Y1, Z1)> for (Y1, Z1)

where Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for(buf: &mut &'a [u8]) -> Result<(Y1, Z1), ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 Y: DataType + DecoderFor<'a, Y>, Z: DataType + DecoderFor<'a, Z>, A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

impl<'a, Z1> DecoderFor<'a, (Z1,)> for (Z1,)

where Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for(buf: &mut &'a [u8]) -> Result<(Z1,), ParseError>

impl<'a, 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> DecoderFor<'a, (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)> 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 Z: DataType + DecoderFor<'a, Z>, A1: DataType + DecoderFor<'a, A1>, B1: DataType + DecoderFor<'a, B1>, C1: DataType + DecoderFor<'a, C1>, D1: DataType + DecoderFor<'a, D1>, E1: DataType + DecoderFor<'a, E1>, F1: DataType + DecoderFor<'a, F1>, G1: DataType + DecoderFor<'a, G1>, H1: DataType + DecoderFor<'a, H1>, I1: DataType + DecoderFor<'a, I1>, J1: DataType + DecoderFor<'a, J1>, K1: DataType + DecoderFor<'a, K1>, L1: DataType + DecoderFor<'a, L1>, M1: DataType + DecoderFor<'a, M1>, N1: DataType + DecoderFor<'a, N1>, O1: DataType + DecoderFor<'a, O1>, P1: DataType + DecoderFor<'a, P1>, Q1: DataType + DecoderFor<'a, Q1>, R1: DataType + DecoderFor<'a, R1>, S1: DataType + DecoderFor<'a, S1>, T1: DataType + DecoderFor<'a, T1>, U1: DataType + DecoderFor<'a, U1>, V1: DataType + DecoderFor<'a, V1>, W1: DataType + DecoderFor<'a, W1>, X1: DataType + DecoderFor<'a, X1>, Y1: DataType + DecoderFor<'a, Y1>, Z1: DataType + DecoderFor<'a, Z1>,

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

fn decode_for( buf: &mut &'a [u8], ) -> Result<(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), ParseError>

Implementors

impl<'a> DecoderFor<'a, DescribeAspect> for DescribeAspect

impl<'a> DecoderFor<'a, InputLanguage> for InputLanguage

impl<'a> DecoderFor<'a, IoFormat> for IoFormat

impl<'a> DecoderFor<'a, TransactionState> for TransactionState

impl<'a> DecoderFor<'a, Encoded<'a>> for Encoded<'a>

impl<'a> DecoderFor<'a, Annotation<'a>> for Annotation<'a>

impl<'a> DecoderFor<'a, Authentication<'a>> for Authentication<'a>

impl<'a> DecoderFor<'a, AuthenticationOk<'a>> for AuthenticationOk<'a>

impl<'a> DecoderFor<'a, AuthenticationRequiredSASLMessage<'a>> for AuthenticationRequiredSASLMessage<'a>

impl<'a> DecoderFor<'a, AuthenticationSASLContinue<'a>> for AuthenticationSASLContinue<'a>

impl<'a> DecoderFor<'a, AuthenticationSASLFinal<'a>> for AuthenticationSASLFinal<'a>

impl<'a> DecoderFor<'a, AuthenticationSASLInitialResponse<'a>> for AuthenticationSASLInitialResponse<'a>

impl<'a> DecoderFor<'a, AuthenticationSASLResponse<'a>> for AuthenticationSASLResponse<'a>

impl<'a> DecoderFor<'a, ClientHandshake<'a>> for ClientHandshake<'a>

impl<'a> DecoderFor<'a, CommandComplete<'a>> for CommandComplete<'a>

impl<'a> DecoderFor<'a, CommandDataDescription<'a>> for CommandDataDescription<'a>

impl<'a> DecoderFor<'a, ConnectionParam<'a>> for ConnectionParam<'a>

impl<'a> DecoderFor<'a, Data<'a>> for Data<'a>

impl<'a> DecoderFor<'a, DataElement<'a>> for DataElement<'a>

impl<'a> DecoderFor<'a, Dump2<'a>> for Dump2<'a>

impl<'a> DecoderFor<'a, Dump3<'a>> for Dump3<'a>

impl<'a> DecoderFor<'a, Dump<'a>> for Dump<'a>

impl<'a> DecoderFor<'a, DumpBlock<'a>> for DumpBlock<'a>

impl<'a> DecoderFor<'a, DumpHeader<'a>> for DumpHeader<'a>

impl<'a> DecoderFor<'a, DumpObjectDesc<'a>> for DumpObjectDesc<'a>

impl<'a> DecoderFor<'a, DumpTypeInfo<'a>> for DumpTypeInfo<'a>

impl<'a> DecoderFor<'a, ErrorResponse<'a>> for ErrorResponse<'a>

impl<'a> DecoderFor<'a, Execute2<'a>> for Execute2<'a>

impl<'a> DecoderFor<'a, Execute<'a>> for Execute<'a>

impl<'a> DecoderFor<'a, KeyValue<'a>> for KeyValue<'a>

impl<'a> DecoderFor<'a, LogMessage<'a>> for LogMessage<'a>

impl<'a> DecoderFor<'a, Message<'a>> for Message<'a>

impl<'a> DecoderFor<'a, ParameterStatus<'a>> for ParameterStatus<'a>

impl<'a> DecoderFor<'a, Parse2<'a>> for Parse2<'a>

impl<'a> DecoderFor<'a, Parse<'a>> for Parse<'a>

impl<'a> DecoderFor<'a, ProtocolExtension<'a>> for ProtocolExtension<'a>

impl<'a> DecoderFor<'a, ReadyForCommand<'a>> for ReadyForCommand<'a>

impl<'a> DecoderFor<'a, Restore<'a>> for Restore<'a>

impl<'a> DecoderFor<'a, RestoreBlock<'a>> for RestoreBlock<'a>

impl<'a> DecoderFor<'a, RestoreEof<'a>> for RestoreEof<'a>

impl<'a> DecoderFor<'a, RestoreReady<'a>> for RestoreReady<'a>

impl<'a> DecoderFor<'a, ServerHandshake<'a>> for ServerHandshake<'a>

impl<'a> DecoderFor<'a, ServerKeyData<'a>> for ServerKeyData<'a>

impl<'a> DecoderFor<'a, StateDataDescription<'a>> for StateDataDescription<'a>

impl<'a> DecoderFor<'a, Sync<'a>> for Sync<'a>

impl<'a> DecoderFor<'a, Terminate<'a>> for Terminate<'a>

impl<'a> DecoderFor<'a, Length> for Length

impl<'a> DecoderFor<'a, Rest<'a>> for Rest<'a>

impl<'a> DecoderFor<'a, Uuid> for Uuid

impl<'a, A> DecoderFor<'a, ArrayString<'a, A>> for ArrayString<'a, A>

where A: ArrayExt<'a> + DecoderFor<'a, A> + DataType, ArrayString<'a, A>: DataType,

impl<'a, L, T> DecoderFor<'a, Array<'a, L, T>> for Array<'a, L, T>

where L: DataType + 'a, T: DataType + DecoderFor<'a, T>,

impl<'a, T> DecoderFor<'a, LengthPrefixed<T>> for LengthPrefixed<T>

where T: DecoderFor<'a, T>,

impl<'a, T> DecoderFor<'a, RestArray<'a, T>> for RestArray<'a, T>

where T: DataType + DecoderFor<'a, T>,

impl<'a, T> DecoderFor<'a, ZTArray<'a, T>> for ZTArray<'a, T>

where T: DataType + DecoderFor<'a, T>,