Trait Serialize

pub trait Serialize: 'static {
    // Required method
    fn serialize<B: Write>(self, buf: &mut B) -> Result<(), SerializeError>;
}

Required Methods

fn serialize<B: Write>(self, buf: &mut B) -> Result<(), SerializeError>

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 Serialize for f32

fn serialize<B: Write>(self, buf: &mut B) -> Result<(), SerializeError>

impl Serialize for f64

fn serialize<B: Write>(self, buf: &mut B) -> Result<(), SerializeError>

impl Serialize for i8

fn serialize<B: Write>(self, buf: &mut B) -> Result<(), SerializeError>

impl Serialize for i16

fn serialize<B: Write>(self, buf: &mut B) -> Result<(), SerializeError>

impl Serialize for i32

fn serialize<B: Write>(self, buf: &mut B) -> Result<(), SerializeError>

impl Serialize for i64

fn serialize<B: Write>(self, buf: &mut B) -> Result<(), SerializeError>

impl Serialize for isize

fn serialize<B: Write>(self, buf: &mut B) -> Result<(), SerializeError>

impl Serialize for u8

fn serialize<B: Write>(self, buf: &mut B) -> Result<(), SerializeError>

impl Serialize for u16

fn serialize<B: Write>(self, buf: &mut B) -> Result<(), SerializeError>

impl Serialize for u32

fn serialize<B: Write>(self, buf: &mut B) -> Result<(), SerializeError>

impl Serialize for u64

fn serialize<B: Write>(self, buf: &mut B) -> Result<(), SerializeError>

impl Serialize for usize

fn serialize<B: Write>(self, buf: &mut B) -> Result<(), SerializeError>

impl Serialize for String

fn serialize<B: Write>(self, buf: &mut B) -> Result<(), SerializeError>

impl<A: Serialize, B: Serialize> Serialize for (A, B)

fn serialize<Buf: Write>(self, buf: &mut Buf) -> Result<(), SerializeError>

impl<A: Serialize, B: Serialize, C: Serialize> Serialize for (A, B, C)

fn serialize<Buf: Write>(self, buf: &mut Buf) -> Result<(), SerializeError>

impl<A: Serialize, B: Serialize, C: Serialize, D: Serialize> Serialize for (A, B, C, D)

fn serialize<Buf: Write>(self, buf: &mut Buf) -> Result<(), SerializeError>

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

fn serialize<Buf: Write>(self, buf: &mut Buf) -> Result<(), SerializeError>

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

fn serialize<Buf: Write>(self, buf: &mut Buf) -> Result<(), SerializeError>

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

fn serialize<Buf: Write>(self, buf: &mut Buf) -> Result<(), SerializeError>

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

fn serialize<Buf: Write>(self, buf: &mut Buf) -> Result<(), SerializeError>

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

fn serialize<Buf: Write>(self, buf: &mut Buf) -> Result<(), SerializeError>

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

fn serialize<Buf: Write>(self, buf: &mut Buf) -> Result<(), SerializeError>

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

fn serialize<Buf: Write>(self, buf: &mut Buf) -> Result<(), SerializeError>

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

fn serialize<Buf: Write>(self, buf: &mut Buf) -> Result<(), SerializeError>

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

fn serialize<Buf: Write>(self, buf: &mut Buf) -> Result<(), SerializeError>

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

fn serialize<Buf: Write>(self, buf: &mut Buf) -> Result<(), SerializeError>

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

fn serialize<Buf: Write>(self, buf: &mut Buf) -> Result<(), SerializeError>

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

fn serialize<Buf: Write>(self, buf: &mut Buf) -> Result<(), SerializeError>

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

fn serialize<Buf: Write>(self, buf: &mut Buf) -> Result<(), SerializeError>

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

fn serialize<Buf: Write>(self, buf: &mut Buf) -> Result<(), SerializeError>

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

fn serialize<Buf: Write>(self, buf: &mut Buf) -> Result<(), SerializeError>

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

fn serialize<Buf: Write>(self, buf: &mut Buf) -> Result<(), SerializeError>

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

fn serialize<Buf: Write>(self, buf: &mut Buf) -> Result<(), SerializeError>

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

fn serialize<Buf: Write>(self, buf: &mut Buf) -> Result<(), SerializeError>

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

fn serialize<Buf: Write>(self, buf: &mut Buf) -> Result<(), SerializeError>

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

fn serialize<Buf: Write>(self, buf: &mut Buf) -> Result<(), SerializeError>

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

fn serialize<Buf: Write>(self, buf: &mut Buf) -> Result<(), SerializeError>

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

fn serialize<Buf: Write>(self, buf: &mut Buf) -> Result<(), SerializeError>

impl<K: Serialize, V: Serialize> Serialize for HashMap<K, V>

fn serialize<B: Write>(self, buf: &mut B) -> Result<(), SerializeError>

impl<T: Serialize> Serialize for Option<T>

fn serialize<B: Write>(self, buf: &mut B) -> Result<(), SerializeError>

impl<T: Serialize> Serialize for Box<T>

fn serialize<B: Write>(self, buf: &mut B) -> Result<(), SerializeError>

impl<T: Serialize> Serialize for Vec<T>

fn serialize<B: Write>(self, buf: &mut B) -> Result<(), SerializeError>

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

fn serialize<B: Write>(self, buf: &mut B) -> Result<(), SerializeError>

Implementors