Trait Encode 

pub trait Encode {
    // Required methods
    fn size(&self) -> Size;
    fn encode(&self, encoder: &mut Encoder<'_>);
}

Represents an encodable type.

Required Methods

fn size(&self) -> Size

Returns the size information for the type.

fn encode(&self, encoder: &mut Encoder<'_>)

Writes the type’s data to the specified encoder.

Notes

Encoding values that do not match what is returned by Encode::size may cause the encoding to panic.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl Encode for &str

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl Encode for &()

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl Encode for str

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl Encode for ()

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl Encode for String

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A> Encode for &(A,)

where A: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A> Encode for (A,)

where A: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B> Encode for &(A, B)

where A: Encode, B: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B> Encode for (A, B)

where A: Encode, B: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C> Encode for &(A, B, C)

where A: Encode, B: Encode, C: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C> Encode for (A, B, C)

where A: Encode, B: Encode, C: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D> Encode for &(A, B, C, D)

where A: Encode, B: Encode, C: Encode, D: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D> Encode for (A, B, C, D)

where A: Encode, B: Encode, C: Encode, D: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E> Encode for &(A, B, C, D, E)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E> Encode for (A, B, C, D, E)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F> Encode for &(A, B, C, D, E, F)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F> Encode for (A, B, C, D, E, F)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G> Encode for &(A, B, C, D, E, F, G)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G> Encode for (A, B, C, D, E, F, G)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H> Encode for &(A, B, C, D, E, F, G, H)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H> Encode for (A, B, C, D, E, F, G, H)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I> Encode for &(A, B, C, D, E, F, G, H, I)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I> Encode for (A, B, C, D, E, F, G, H, I)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J> Encode for &(A, B, C, D, E, F, G, H, I, J)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J> Encode for (A, B, C, D, E, F, G, H, I, J)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J, K> Encode for &(A, B, C, D, E, F, G, H, I, J, K)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J, K> Encode for (A, B, C, D, E, F, G, H, I, J, K)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J, K, L> Encode for &(A, B, C, D, E, F, G, H, I, J, K, L)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J, K, L> Encode for (A, B, C, D, E, F, G, H, I, J, K, L)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M> Encode for &(A, B, C, D, E, F, G, H, I, J, K, L, M)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M> Encode for (A, B, C, D, E, F, G, H, I, J, K, L, M)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N> Encode for &(A, B, C, D, E, F, G, H, I, J, K, L, M, N)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N> Encode for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Encode for &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O> Encode for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Encode for &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P> Encode for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> Encode for &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q> Encode for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> Encode for &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R> Encode for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> Encode for &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S> Encode for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Encode for &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T> Encode for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> Encode for &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode, U: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U> Encode for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode, U: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> Encode for &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode, U: Encode, V: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> Encode for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode, U: Encode, V: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W> Encode for &(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode, U: Encode, V: Encode, W: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W> Encode for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode, U: Encode, V: Encode, W: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

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> Encode 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)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode, U: Encode, V: Encode, W: Encode, X: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

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> Encode 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)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode, U: Encode, V: Encode, W: Encode, X: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

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> Encode 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)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode, U: Encode, V: Encode, W: Encode, X: Encode, Y: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

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> Encode 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)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode, U: Encode, V: Encode, W: Encode, X: Encode, Y: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

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> Encode 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)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode, U: Encode, V: Encode, W: Encode, X: Encode, Y: Encode, Z: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

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> Encode 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)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode, U: Encode, V: Encode, W: Encode, X: Encode, Y: Encode, Z: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

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, AA> Encode 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, AA)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode, U: Encode, V: Encode, W: Encode, X: Encode, Y: Encode, Z: Encode, AA: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

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, AA> Encode 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, AA)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode, U: Encode, V: Encode, W: Encode, X: Encode, Y: Encode, Z: Encode, AA: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

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, AA, AB> Encode 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, AA, AB)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode, U: Encode, V: Encode, W: Encode, X: Encode, Y: Encode, Z: Encode, AA: Encode, AB: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

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, AA, AB> Encode 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, AA, AB)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode, U: Encode, V: Encode, W: Encode, X: Encode, Y: Encode, Z: Encode, AA: Encode, AB: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

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, AA, AB, AC> Encode 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, AA, AB, AC)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode, U: Encode, V: Encode, W: Encode, X: Encode, Y: Encode, Z: Encode, AA: Encode, AB: Encode, AC: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

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, AA, AB, AC> Encode 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, AA, AB, AC)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode, U: Encode, V: Encode, W: Encode, X: Encode, Y: Encode, Z: Encode, AA: Encode, AB: Encode, AC: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

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, AA, AB, AC, AD> Encode 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, AA, AB, AC, AD)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode, U: Encode, V: Encode, W: Encode, X: Encode, Y: Encode, Z: Encode, AA: Encode, AB: Encode, AC: Encode, AD: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

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, AA, AB, AC, AD> Encode 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, AA, AB, AC, AD)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode, U: Encode, V: Encode, W: Encode, X: Encode, Y: Encode, Z: Encode, AA: Encode, AB: Encode, AC: Encode, AD: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

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, AA, AB, AC, AD, AE> Encode 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, AA, AB, AC, AD, AE)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode, U: Encode, V: Encode, W: Encode, X: Encode, Y: Encode, Z: Encode, AA: Encode, AB: Encode, AC: Encode, AD: Encode, AE: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

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, AA, AB, AC, AD, AE> Encode 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, AA, AB, AC, AD, AE)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode, U: Encode, V: Encode, W: Encode, X: Encode, Y: Encode, Z: Encode, AA: Encode, AB: Encode, AC: Encode, AD: Encode, AE: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

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, AA, AB, AC, AD, AE, AF> Encode 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, AA, AB, AC, AD, AE, AF)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode, U: Encode, V: Encode, W: Encode, X: Encode, Y: Encode, Z: Encode, AA: Encode, AB: Encode, AC: Encode, AD: Encode, AE: Encode, AF: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

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, AA, AB, AC, AD, AE, AF> Encode 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, AA, AB, AC, AD, AE, AF)

where A: Encode, B: Encode, C: Encode, D: Encode, E: Encode, F: Encode, G: Encode, H: Encode, I: Encode, J: Encode, K: Encode, L: Encode, M: Encode, N: Encode, O: Encode, P: Encode, Q: Encode, R: Encode, S: Encode, T: Encode, U: Encode, V: Encode, W: Encode, X: Encode, Y: Encode, Z: Encode, AA: Encode, AB: Encode, AC: Encode, AD: Encode, AE: Encode, AF: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<T> Encode for &[T]

where T: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<T> Encode for Cow<'_, T>

where T: Encode + ToOwned + ?Sized,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<T> Encode for [T]

where T: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<T> Encode for Vec<T>

where T: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

impl<T, const N: usize> Encode for &[T; N]

where T: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

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

where T: Encode,

fn size(&self) -> Size

fn encode(&self, encoder: &mut Encoder<'_>)

Implementors

impl Encode for Bytes<&[u8]>

impl Encode for Bytes<Vec<u8>>

impl Encode for Bytes<[u8]>

impl<T> Encode for T

where T: Primitive,