Trait Encodable

pub trait Encodable<E>
where
    E: Encoder,
{
    type Error: From<E::Error>;

    // Required method
    fn encode(&self, encoder: &mut E) -> Result<(), Self::Error>;
}

A type that can be encoded into an encoder.

An encoder must be pure, meaning that it has to uphold the following properties:

• It must have no side effects
• It must produce the same outputs for the same inputs

Some examples of non-indepotent encodes are:

• Writing to a file or other I/O device
• Using random number generators
• Panics
• Using global state

Required Associated Types

type Error: From<E::Error>

The error type that can be returned when encoding self.

For example, some encodables may abort encoding if encoding would produce an invalid byte stream as dictated by the encoding format.

Required Methods

fn encode(&self, encoder: &mut E) -> Result<(), Self::Error>

Encodes self into the given encoder.

Errors

Implementations of this method should return an error if encoding fails due to an encoder error or if the encoding would produce an invalid byte stream as dictated by the encoding format.

Implementations on Foreign Types

impl<E> Encodable<E> for str

where E: Encoder,

type Error = <E as Encoder>::Error

fn encode(&self, encoder: &mut E) -> Result<(), Self::Error>

impl<E> Encodable<E> for CStr

where E: Encoder,

type Error = <E as Encoder>::Error

fn encode(&self, encoder: &mut E) -> Result<(), Self::Error>

impl<E> Encodable<E> for [u8]

where E: Encoder,

type Error = <E as Encoder>::Error

fn encode(&self, encoder: &mut E) -> Result<(), Self::Error>

impl<E: Encoder> Encodable<E> for char

type Error = <E as Encoder>::Error

fn encode(&self, encoder: &mut E) -> Result<(), Self::Error>

impl<E: Encoder> Encodable<E> for i8

type Error = <E as Encoder>::Error

fn encode(&self, encoder: &mut E) -> Result<(), Self::Error>

impl<E: Encoder> Encodable<E> for u8

type Error = <E as Encoder>::Error

fn encode(&self, encoder: &mut E) -> Result<(), Self::Error>

impl<E: Encoder> Encodable<E> for ()

type Error = <E as Encoder>::Error

fn encode(&self, _encoder: &mut E) -> Result<(), Self::Error>

impl<E: Encoder> Encodable<E> for String

type Error = <E as Encoder>::Error

fn encode(&self, encoder: &mut E) -> Result<(), Self::Error>

impl<E: Encoder> Encodable<E> for Vec<u8>

type Error = <E as Encoder>::Error

fn encode(&self, encoder: &mut E) -> Result<(), Self::Error>

impl<E: Encoder> Encodable<E> for Arguments<'_>

type Error = <E as Encoder>::Error

fn encode(&self, encoder: &mut E) -> Result<(), Self::Error>

impl<E: Encoder, T> Encodable<E> for Cow<'_, T>

where T: Clone + Encodable<E>,

type Error = <T as Encodable<E>>::Error

fn encode(&self, encoder: &mut E) -> Result<(), Self::Error>

impl<E: Encoder, T: Encodable<E>> Encodable<E> for Box<T>

type Error = <T as Encodable<E>>::Error

fn encode(&self, encoder: &mut E) -> Result<(), Self::Error>

impl<ENC, A> Encodable<ENC> for (A,)

where ENC: Encoder, A: Encodable<ENC>,

type Error = <A as Encodable<ENC>>::Error

fn encode(&self, encoder: &mut ENC) -> Result<(), Self::Error>

impl<ENC, A, B> Encodable<ENC> for (A, B)

where ENC: Encoder, A: Encodable<ENC>, B: Encodable<ENC, Error = A::Error>,

type Error = <A as Encodable<ENC>>::Error

fn encode(&self, encoder: &mut ENC) -> Result<(), Self::Error>

impl<ENC, A, B, C> Encodable<ENC> for (A, B, C)

where ENC: Encoder, A: Encodable<ENC>, B: Encodable<ENC, Error = A::Error>, C: Encodable<ENC, Error = A::Error>,

type Error = <A as Encodable<ENC>>::Error

fn encode(&self, encoder: &mut ENC) -> Result<(), Self::Error>

impl<ENC, A, B, C, D> Encodable<ENC> for (A, B, C, D)

where ENC: Encoder, A: Encodable<ENC>, B: Encodable<ENC, Error = A::Error>, C: Encodable<ENC, Error = A::Error>, D: Encodable<ENC, Error = A::Error>,

type Error = <A as Encodable<ENC>>::Error

fn encode(&self, encoder: &mut ENC) -> Result<(), Self::Error>

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

where ENC: Encoder, A: Encodable<ENC>, B: Encodable<ENC, Error = A::Error>, C: Encodable<ENC, Error = A::Error>, D: Encodable<ENC, Error = A::Error>, E: Encodable<ENC, Error = A::Error>,

type Error = <A as Encodable<ENC>>::Error

fn encode(&self, encoder: &mut ENC) -> Result<(), Self::Error>

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

where ENC: Encoder, A: Encodable<ENC>, B: Encodable<ENC, Error = A::Error>, C: Encodable<ENC, Error = A::Error>, D: Encodable<ENC, Error = A::Error>, E: Encodable<ENC, Error = A::Error>, F: Encodable<ENC, Error = A::Error>,

type Error = <A as Encodable<ENC>>::Error

fn encode(&self, encoder: &mut ENC) -> Result<(), Self::Error>

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

where ENC: Encoder, A: Encodable<ENC>, B: Encodable<ENC, Error = A::Error>, C: Encodable<ENC, Error = A::Error>, D: Encodable<ENC, Error = A::Error>, E: Encodable<ENC, Error = A::Error>, F: Encodable<ENC, Error = A::Error>, G: Encodable<ENC, Error = A::Error>,

type Error = <A as Encodable<ENC>>::Error

fn encode(&self, encoder: &mut ENC) -> Result<(), Self::Error>

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

where ENC: Encoder, A: Encodable<ENC>, B: Encodable<ENC, Error = A::Error>, C: Encodable<ENC, Error = A::Error>, D: Encodable<ENC, Error = A::Error>, E: Encodable<ENC, Error = A::Error>, F: Encodable<ENC, Error = A::Error>, G: Encodable<ENC, Error = A::Error>, H: Encodable<ENC, Error = A::Error>,

type Error = <A as Encodable<ENC>>::Error

fn encode(&self, encoder: &mut ENC) -> Result<(), Self::Error>

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

where ENC: Encoder, A: Encodable<ENC>, B: Encodable<ENC, Error = A::Error>, C: Encodable<ENC, Error = A::Error>, D: Encodable<ENC, Error = A::Error>, E: Encodable<ENC, Error = A::Error>, F: Encodable<ENC, Error = A::Error>, G: Encodable<ENC, Error = A::Error>, H: Encodable<ENC, Error = A::Error>, I: Encodable<ENC, Error = A::Error>,

type Error = <A as Encodable<ENC>>::Error

fn encode(&self, encoder: &mut ENC) -> Result<(), Self::Error>

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

where ENC: Encoder, A: Encodable<ENC>, B: Encodable<ENC, Error = A::Error>, C: Encodable<ENC, Error = A::Error>, D: Encodable<ENC, Error = A::Error>, E: Encodable<ENC, Error = A::Error>, F: Encodable<ENC, Error = A::Error>, G: Encodable<ENC, Error = A::Error>, H: Encodable<ENC, Error = A::Error>, I: Encodable<ENC, Error = A::Error>, J: Encodable<ENC, Error = A::Error>,

type Error = <A as Encodable<ENC>>::Error

fn encode(&self, encoder: &mut ENC) -> Result<(), Self::Error>

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

where ENC: Encoder, A: Encodable<ENC>, B: Encodable<ENC, Error = A::Error>, C: Encodable<ENC, Error = A::Error>, D: Encodable<ENC, Error = A::Error>, E: Encodable<ENC, Error = A::Error>, F: Encodable<ENC, Error = A::Error>, G: Encodable<ENC, Error = A::Error>, H: Encodable<ENC, Error = A::Error>, I: Encodable<ENC, Error = A::Error>, J: Encodable<ENC, Error = A::Error>, K: Encodable<ENC, Error = A::Error>,

type Error = <A as Encodable<ENC>>::Error

fn encode(&self, encoder: &mut ENC) -> Result<(), Self::Error>

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

where ENC: Encoder, A: Encodable<ENC>, B: Encodable<ENC, Error = A::Error>, C: Encodable<ENC, Error = A::Error>, D: Encodable<ENC, Error = A::Error>, E: Encodable<ENC, Error = A::Error>, F: Encodable<ENC, Error = A::Error>, G: Encodable<ENC, Error = A::Error>, H: Encodable<ENC, Error = A::Error>, I: Encodable<ENC, Error = A::Error>, J: Encodable<ENC, Error = A::Error>, K: Encodable<ENC, Error = A::Error>, L: Encodable<ENC, Error = A::Error>,

type Error = <A as Encodable<ENC>>::Error

fn encode(&self, encoder: &mut ENC) -> Result<(), Self::Error>

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

where ENC: Encoder, A: Encodable<ENC>, B: Encodable<ENC, Error = A::Error>, C: Encodable<ENC, Error = A::Error>, D: Encodable<ENC, Error = A::Error>, E: Encodable<ENC, Error = A::Error>, F: Encodable<ENC, Error = A::Error>, G: Encodable<ENC, Error = A::Error>, H: Encodable<ENC, Error = A::Error>, I: Encodable<ENC, Error = A::Error>, J: Encodable<ENC, Error = A::Error>, K: Encodable<ENC, Error = A::Error>, L: Encodable<ENC, Error = A::Error>, M: Encodable<ENC, Error = A::Error>,

type Error = <A as Encodable<ENC>>::Error

fn encode(&self, encoder: &mut ENC) -> Result<(), Self::Error>

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

where ENC: Encoder, A: Encodable<ENC>, B: Encodable<ENC, Error = A::Error>, C: Encodable<ENC, Error = A::Error>, D: Encodable<ENC, Error = A::Error>, E: Encodable<ENC, Error = A::Error>, F: Encodable<ENC, Error = A::Error>, G: Encodable<ENC, Error = A::Error>, H: Encodable<ENC, Error = A::Error>, I: Encodable<ENC, Error = A::Error>, J: Encodable<ENC, Error = A::Error>, K: Encodable<ENC, Error = A::Error>, L: Encodable<ENC, Error = A::Error>, M: Encodable<ENC, Error = A::Error>, N: Encodable<ENC, Error = A::Error>,

type Error = <A as Encodable<ENC>>::Error

fn encode(&self, encoder: &mut ENC) -> Result<(), Self::Error>

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

where ENC: Encoder, A: Encodable<ENC>, B: Encodable<ENC, Error = A::Error>, C: Encodable<ENC, Error = A::Error>, D: Encodable<ENC, Error = A::Error>, E: Encodable<ENC, Error = A::Error>, F: Encodable<ENC, Error = A::Error>, G: Encodable<ENC, Error = A::Error>, H: Encodable<ENC, Error = A::Error>, I: Encodable<ENC, Error = A::Error>, J: Encodable<ENC, Error = A::Error>, K: Encodable<ENC, Error = A::Error>, L: Encodable<ENC, Error = A::Error>, M: Encodable<ENC, Error = A::Error>, N: Encodable<ENC, Error = A::Error>, O: Encodable<ENC, Error = A::Error>,

type Error = <A as Encodable<ENC>>::Error

fn encode(&self, encoder: &mut ENC) -> Result<(), Self::Error>

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

where ENC: Encoder, A: Encodable<ENC>, B: Encodable<ENC, Error = A::Error>, C: Encodable<ENC, Error = A::Error>, D: Encodable<ENC, Error = A::Error>, E: Encodable<ENC, Error = A::Error>, F: Encodable<ENC, Error = A::Error>, G: Encodable<ENC, Error = A::Error>, H: Encodable<ENC, Error = A::Error>, I: Encodable<ENC, Error = A::Error>, J: Encodable<ENC, Error = A::Error>, K: Encodable<ENC, Error = A::Error>, L: Encodable<ENC, Error = A::Error>, M: Encodable<ENC, Error = A::Error>, N: Encodable<ENC, Error = A::Error>, O: Encodable<ENC, Error = A::Error>, P: Encodable<ENC, Error = A::Error>,

type Error = <A as Encodable<ENC>>::Error

fn encode(&self, encoder: &mut ENC) -> Result<(), Self::Error>

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

where ENC: Encoder, A: Encodable<ENC>, B: Encodable<ENC, Error = A::Error>, C: Encodable<ENC, Error = A::Error>, D: Encodable<ENC, Error = A::Error>, E: Encodable<ENC, Error = A::Error>, F: Encodable<ENC, Error = A::Error>, G: Encodable<ENC, Error = A::Error>, H: Encodable<ENC, Error = A::Error>, I: Encodable<ENC, Error = A::Error>, J: Encodable<ENC, Error = A::Error>, K: Encodable<ENC, Error = A::Error>, L: Encodable<ENC, Error = A::Error>, M: Encodable<ENC, Error = A::Error>, N: Encodable<ENC, Error = A::Error>, O: Encodable<ENC, Error = A::Error>, P: Encodable<ENC, Error = A::Error>, Q: Encodable<ENC, Error = A::Error>,

type Error = <A as Encodable<ENC>>::Error

fn encode(&self, encoder: &mut ENC) -> Result<(), Self::Error>

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

where ENC: Encoder, A: Encodable<ENC>, B: Encodable<ENC, Error = A::Error>, C: Encodable<ENC, Error = A::Error>, D: Encodable<ENC, Error = A::Error>, E: Encodable<ENC, Error = A::Error>, F: Encodable<ENC, Error = A::Error>, G: Encodable<ENC, Error = A::Error>, H: Encodable<ENC, Error = A::Error>, I: Encodable<ENC, Error = A::Error>, J: Encodable<ENC, Error = A::Error>, K: Encodable<ENC, Error = A::Error>, L: Encodable<ENC, Error = A::Error>, M: Encodable<ENC, Error = A::Error>, N: Encodable<ENC, Error = A::Error>, O: Encodable<ENC, Error = A::Error>, P: Encodable<ENC, Error = A::Error>, Q: Encodable<ENC, Error = A::Error>, R: Encodable<ENC, Error = A::Error>,

type Error = <A as Encodable<ENC>>::Error

fn encode(&self, encoder: &mut ENC) -> Result<(), Self::Error>

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

where ENC: Encoder, A: Encodable<ENC>, B: Encodable<ENC, Error = A::Error>, C: Encodable<ENC, Error = A::Error>, D: Encodable<ENC, Error = A::Error>, E: Encodable<ENC, Error = A::Error>, F: Encodable<ENC, Error = A::Error>, G: Encodable<ENC, Error = A::Error>, H: Encodable<ENC, Error = A::Error>, I: Encodable<ENC, Error = A::Error>, J: Encodable<ENC, Error = A::Error>, K: Encodable<ENC, Error = A::Error>, L: Encodable<ENC, Error = A::Error>, M: Encodable<ENC, Error = A::Error>, N: Encodable<ENC, Error = A::Error>, O: Encodable<ENC, Error = A::Error>, P: Encodable<ENC, Error = A::Error>, Q: Encodable<ENC, Error = A::Error>, R: Encodable<ENC, Error = A::Error>, S: Encodable<ENC, Error = A::Error>,

type Error = <A as Encodable<ENC>>::Error

fn encode(&self, encoder: &mut ENC) -> Result<(), Self::Error>

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

where ENC: Encoder, A: Encodable<ENC>, B: Encodable<ENC, Error = A::Error>, C: Encodable<ENC, Error = A::Error>, D: Encodable<ENC, Error = A::Error>, E: Encodable<ENC, Error = A::Error>, F: Encodable<ENC, Error = A::Error>, G: Encodable<ENC, Error = A::Error>, H: Encodable<ENC, Error = A::Error>, I: Encodable<ENC, Error = A::Error>, J: Encodable<ENC, Error = A::Error>, K: Encodable<ENC, Error = A::Error>, L: Encodable<ENC, Error = A::Error>, M: Encodable<ENC, Error = A::Error>, N: Encodable<ENC, Error = A::Error>, O: Encodable<ENC, Error = A::Error>, P: Encodable<ENC, Error = A::Error>, Q: Encodable<ENC, Error = A::Error>, R: Encodable<ENC, Error = A::Error>, S: Encodable<ENC, Error = A::Error>, T: Encodable<ENC, Error = A::Error>,

type Error = <A as Encodable<ENC>>::Error

fn encode(&self, encoder: &mut ENC) -> Result<(), Self::Error>

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

where ENC: Encoder, A: Encodable<ENC>, B: Encodable<ENC, Error = A::Error>, C: Encodable<ENC, Error = A::Error>, D: Encodable<ENC, Error = A::Error>, E: Encodable<ENC, Error = A::Error>, F: Encodable<ENC, Error = A::Error>, G: Encodable<ENC, Error = A::Error>, H: Encodable<ENC, Error = A::Error>, I: Encodable<ENC, Error = A::Error>, J: Encodable<ENC, Error = A::Error>, K: Encodable<ENC, Error = A::Error>, L: Encodable<ENC, Error = A::Error>, M: Encodable<ENC, Error = A::Error>, N: Encodable<ENC, Error = A::Error>, O: Encodable<ENC, Error = A::Error>, P: Encodable<ENC, Error = A::Error>, Q: Encodable<ENC, Error = A::Error>, R: Encodable<ENC, Error = A::Error>, S: Encodable<ENC, Error = A::Error>, T: Encodable<ENC, Error = A::Error>, U: Encodable<ENC, Error = A::Error>,

type Error = <A as Encodable<ENC>>::Error

fn encode(&self, encoder: &mut ENC) -> Result<(), Self::Error>

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

where ENC: Encoder, A: Encodable<ENC>, B: Encodable<ENC, Error = A::Error>, C: Encodable<ENC, Error = A::Error>, D: Encodable<ENC, Error = A::Error>, E: Encodable<ENC, Error = A::Error>, F: Encodable<ENC, Error = A::Error>, G: Encodable<ENC, Error = A::Error>, H: Encodable<ENC, Error = A::Error>, I: Encodable<ENC, Error = A::Error>, J: Encodable<ENC, Error = A::Error>, K: Encodable<ENC, Error = A::Error>, L: Encodable<ENC, Error = A::Error>, M: Encodable<ENC, Error = A::Error>, N: Encodable<ENC, Error = A::Error>, O: Encodable<ENC, Error = A::Error>, P: Encodable<ENC, Error = A::Error>, Q: Encodable<ENC, Error = A::Error>, R: Encodable<ENC, Error = A::Error>, S: Encodable<ENC, Error = A::Error>, T: Encodable<ENC, Error = A::Error>, U: Encodable<ENC, Error = A::Error>, V: Encodable<ENC, Error = A::Error>,

type Error = <A as Encodable<ENC>>::Error

fn encode(&self, encoder: &mut ENC) -> Result<(), Self::Error>

impl<ENC, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W> Encodable<ENC> 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 ENC: Encoder, A: Encodable<ENC>, B: Encodable<ENC, Error = A::Error>, C: Encodable<ENC, Error = A::Error>, D: Encodable<ENC, Error = A::Error>, E: Encodable<ENC, Error = A::Error>, F: Encodable<ENC, Error = A::Error>, G: Encodable<ENC, Error = A::Error>, H: Encodable<ENC, Error = A::Error>, I: Encodable<ENC, Error = A::Error>, J: Encodable<ENC, Error = A::Error>, K: Encodable<ENC, Error = A::Error>, L: Encodable<ENC, Error = A::Error>, M: Encodable<ENC, Error = A::Error>, N: Encodable<ENC, Error = A::Error>, O: Encodable<ENC, Error = A::Error>, P: Encodable<ENC, Error = A::Error>, Q: Encodable<ENC, Error = A::Error>, R: Encodable<ENC, Error = A::Error>, S: Encodable<ENC, Error = A::Error>, T: Encodable<ENC, Error = A::Error>, U: Encodable<ENC, Error = A::Error>, V: Encodable<ENC, Error = A::Error>, W: Encodable<ENC, Error = A::Error>,

type Error = <A as Encodable<ENC>>::Error

fn encode(&self, encoder: &mut ENC) -> Result<(), Self::Error>

impl<ENC, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> Encodable<ENC> 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 ENC: Encoder, A: Encodable<ENC>, B: Encodable<ENC, Error = A::Error>, C: Encodable<ENC, Error = A::Error>, D: Encodable<ENC, Error = A::Error>, E: Encodable<ENC, Error = A::Error>, F: Encodable<ENC, Error = A::Error>, G: Encodable<ENC, Error = A::Error>, H: Encodable<ENC, Error = A::Error>, I: Encodable<ENC, Error = A::Error>, J: Encodable<ENC, Error = A::Error>, K: Encodable<ENC, Error = A::Error>, L: Encodable<ENC, Error = A::Error>, M: Encodable<ENC, Error = A::Error>, N: Encodable<ENC, Error = A::Error>, O: Encodable<ENC, Error = A::Error>, P: Encodable<ENC, Error = A::Error>, Q: Encodable<ENC, Error = A::Error>, R: Encodable<ENC, Error = A::Error>, S: Encodable<ENC, Error = A::Error>, T: Encodable<ENC, Error = A::Error>, U: Encodable<ENC, Error = A::Error>, V: Encodable<ENC, Error = A::Error>, W: Encodable<ENC, Error = A::Error>, X: Encodable<ENC, Error = A::Error>,

type Error = <A as Encodable<ENC>>::Error

fn encode(&self, encoder: &mut ENC) -> Result<(), Self::Error>

impl<ENC, 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> Encodable<ENC> 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 ENC: Encoder, A: Encodable<ENC>, B: Encodable<ENC, Error = A::Error>, C: Encodable<ENC, Error = A::Error>, D: Encodable<ENC, Error = A::Error>, E: Encodable<ENC, Error = A::Error>, F: Encodable<ENC, Error = A::Error>, G: Encodable<ENC, Error = A::Error>, H: Encodable<ENC, Error = A::Error>, I: Encodable<ENC, Error = A::Error>, J: Encodable<ENC, Error = A::Error>, K: Encodable<ENC, Error = A::Error>, L: Encodable<ENC, Error = A::Error>, M: Encodable<ENC, Error = A::Error>, N: Encodable<ENC, Error = A::Error>, O: Encodable<ENC, Error = A::Error>, P: Encodable<ENC, Error = A::Error>, Q: Encodable<ENC, Error = A::Error>, R: Encodable<ENC, Error = A::Error>, S: Encodable<ENC, Error = A::Error>, T: Encodable<ENC, Error = A::Error>, U: Encodable<ENC, Error = A::Error>, V: Encodable<ENC, Error = A::Error>, W: Encodable<ENC, Error = A::Error>, X: Encodable<ENC, Error = A::Error>, Y: Encodable<ENC, Error = A::Error>,

type Error = <A as Encodable<ENC>>::Error

fn encode(&self, encoder: &mut ENC) -> Result<(), Self::Error>

impl<ENC, 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> Encodable<ENC> 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 ENC: Encoder, A: Encodable<ENC>, B: Encodable<ENC, Error = A::Error>, C: Encodable<ENC, Error = A::Error>, D: Encodable<ENC, Error = A::Error>, E: Encodable<ENC, Error = A::Error>, F: Encodable<ENC, Error = A::Error>, G: Encodable<ENC, Error = A::Error>, H: Encodable<ENC, Error = A::Error>, I: Encodable<ENC, Error = A::Error>, J: Encodable<ENC, Error = A::Error>, K: Encodable<ENC, Error = A::Error>, L: Encodable<ENC, Error = A::Error>, M: Encodable<ENC, Error = A::Error>, N: Encodable<ENC, Error = A::Error>, O: Encodable<ENC, Error = A::Error>, P: Encodable<ENC, Error = A::Error>, Q: Encodable<ENC, Error = A::Error>, R: Encodable<ENC, Error = A::Error>, S: Encodable<ENC, Error = A::Error>, T: Encodable<ENC, Error = A::Error>, U: Encodable<ENC, Error = A::Error>, V: Encodable<ENC, Error = A::Error>, W: Encodable<ENC, Error = A::Error>, X: Encodable<ENC, Error = A::Error>, Y: Encodable<ENC, Error = A::Error>, Z: Encodable<ENC, Error = A::Error>,

type Error = <A as Encodable<ENC>>::Error

fn encode(&self, encoder: &mut ENC) -> Result<(), Self::Error>

impl<Encoder> Encodable<Encoder> for bool

where Encoder: Encoder,

type Error = <Encoder as Encoder>::Error

fn encode(&self, encoder: &mut Encoder) -> Result<(), Self::Error>

impl<T, E> Encodable<E> for Option<T>

where T: Encodable<E>, E: Encoder,

type Error = <T as Encodable<E>>::Error

fn encode(&self, encoder: &mut E) -> Result<(), Self::Error>

impl<T, E> Encodable<E> for Result<T, T::Error>

where T: Encodable<E>, E: Encoder, T::Error: Clone,

type Error = <T as Encodable<E>>::Error

fn encode(&self, encoder: &mut E) -> Result<(), Self::Error>

impl<T, Encoder> Encodable<Encoder> for &T

where T: Encodable<Encoder> + ?Sized, Encoder: Encoder,

type Error = <T as Encodable<Encoder>>::Error

fn encode(&self, encoder: &mut Encoder) -> Result<(), Self::Error>

impl<const SIZE: usize, E> Encodable<E> for [u8; SIZE]

where E: Encoder,

type Error = <E as Encoder>::Error

fn encode(&self, encoder: &mut E) -> Result<(), Self::Error>

Implementors

impl<E: Encoder> Encodable<E> for BE<f32>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for BE<f64>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for BE<i8>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for BE<i16>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for BE<i32>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for BE<i64>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for BE<i128>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for BE<u8>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for BE<u16>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for BE<u32>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for BE<u64>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for BE<u128>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for BE<NonZero<i8>>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for BE<NonZero<i16>>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for BE<NonZero<i32>>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for BE<NonZero<i64>>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for BE<NonZero<i128>>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for BE<NonZero<u8>>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for BE<NonZero<u16>>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for BE<NonZero<u32>>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for BE<NonZero<u64>>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for BE<NonZero<u128>>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for Flags

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for LE<f32>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for LE<f64>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for LE<i8>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for LE<i16>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for LE<i32>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for LE<i64>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for LE<i128>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for LE<u8>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for LE<u16>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for LE<u32>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for LE<u64>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for LE<u128>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for LE<NonZero<i8>>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for LE<NonZero<i16>>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for LE<NonZero<i32>>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for LE<NonZero<i64>>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for LE<NonZero<i128>>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for LE<NonZero<u8>>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for LE<NonZero<u16>>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for LE<NonZero<u32>>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for LE<NonZero<u64>>

type Error = <E as Encoder>::Error

impl<E: Encoder> Encodable<E> for LE<NonZero<u128>>

type Error = <E as Encoder>::Error

impl<Encodable, Encoder, DstError> Encodable<Encoder> for FromError<Encodable, DstError>

where DstError: From<Encodable::Error> + From<Encoder::Error>, Encodable: Encodable<Encoder>, Encoder: Encoder,

type Error = DstError

impl<Encodable, Encoder, F> Encodable<Encoder> for Cond<Encodable, F>

where Encodable: Encodable<Encoder>, Encoder: Encoder, F: Fn(&Encodable) -> bool,

type Error = <Encodable as Encodable<Encoder>>::Error

impl<Encodable, Length, Encoder, Error> Encodable<Encoder> for LengthPrefix<Encodable, Length, Error>

where Encoder: Encoder, Encodable: Encodable<Encoder> + EncodableSize, Length: Encodable<Encoder> + TryFrom<usize>, Error: From<<Length as Encodable<Encoder>>::Error> + From<<Length as TryFrom<usize>>::Error> + From<<Encodable as Encodable<Encoder>>::Error> + From<<Encodable as Encodable<SizeEncoder>>::Error> + From<Encoder::Error>,

type Error = Error

impl<EncodableIter, Encoder> Encodable<Encoder> for Iter<EncodableIter>

where EncodableIter: IntoIterator + Clone, EncodableIter::Item: Encodable<Encoder>, Encoder: Encoder,

type Error = <<EncodableIter as IntoIterator>::Item as Encodable<Encoder>>::Error

impl<EncodableIter, Separator, Encoder> Encodable<Encoder> for Separated<EncodableIter, Separator>

where EncodableIter: IntoIterator + Clone, EncodableIter::Item: Encodable<Encoder, Error = Separator::Error>, Separator: Encodable<Encoder>, Encoder: Encoder,

type Error = <Separator as Encodable<Encoder>>::Error