Trait Serialize 

pub trait Serialize {
    // Required method
    fn serialize<S>(
        &self,
        serializer: &mut S,
    ) -> Result<(), <S as Serializer>::Error>
       where S: Serializer;
}

A trait that describes a type that can be serialized by a Serializer.

Required Methods

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

Serializes this value into this serializer.

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 SocketAddr

Available on crate feature std only.

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl Serialize for bool

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl Serialize for char

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl Serialize for f32

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl Serialize for f64

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl Serialize for i8

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl Serialize for i16

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl Serialize for i32

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl Serialize for i64

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl Serialize for isize

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl Serialize for str

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl Serialize for u8

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl Serialize for u16

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl Serialize for u32

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl Serialize for u64

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl Serialize for ()

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl Serialize for usize

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl Serialize for String

Available on crate features std or collections only.

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl Serialize for Ipv4Addr

Available on crate feature std only.

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl Serialize for Ipv6Addr

Available on crate feature std only.

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl Serialize for SocketAddrV4

Available on crate feature std only.

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl Serialize for SocketAddrV6

Available on crate feature std only.

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl Serialize for Path

Available on crate feature std only.

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl Serialize for PathBuf

Available on crate feature std only.

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<'a, T> Serialize for Cow<'a, T>

where T: Serialize + ToOwned + ?Sized,

Available on crate features std or collections only.

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<'a, T> Serialize for &'a T

where T: Serialize + ?Sized,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<'a, T> Serialize for &'a mut T

where T: Serialize + ?Sized,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<K, V> Serialize for BTreeMap<K, V>

where K: Serialize + Ord, V: Serialize,

Available on crate features std or collections only.

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

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

where K: Serialize + Eq + Hash, V: Serialize, H: BuildHasher,

Available on crate feature std only.

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T0> Serialize for (T0,)

where T0: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1> Serialize for (T0, T1)

where T0: Serialize, T1: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2> Serialize for (T0, T1, T2)

where T0: Serialize, T1: Serialize, T2: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2, T3> Serialize for (T0, T1, T2, T3)

where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2, T3, T4> Serialize for (T0, T1, T2, T3, T4)

where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2, T3, T4, T5> Serialize for (T0, T1, T2, T3, T4, T5)

where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize, T5: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2, T3, T4, T5, T6> Serialize for (T0, T1, T2, T3, T4, T5, T6)

where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize, T5: Serialize, T6: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2, T3, T4, T5, T6, T7> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7)

where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize, T5: Serialize, T6: Serialize, T7: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8)

where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize, T5: Serialize, T6: Serialize, T7: Serialize, T8: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)

where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize, T5: Serialize, T6: Serialize, T7: Serialize, T8: Serialize, T9: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)

where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize, T5: Serialize, T6: Serialize, T7: Serialize, T8: Serialize, T9: Serialize, T10: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)

where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize, T5: Serialize, T6: Serialize, T7: Serialize, T8: Serialize, T9: Serialize, T10: Serialize, T11: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12)

where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize, T5: Serialize, T6: Serialize, T7: Serialize, T8: Serialize, T9: Serialize, T10: Serialize, T11: Serialize, T12: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13)

where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize, T5: Serialize, T6: Serialize, T7: Serialize, T8: Serialize, T9: Serialize, T10: Serialize, T11: Serialize, T12: Serialize, T13: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14)

where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize, T5: Serialize, T6: Serialize, T7: Serialize, T8: Serialize, T9: Serialize, T10: Serialize, T11: Serialize, T12: Serialize, T13: Serialize, T14: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Serialize for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15)

where T0: Serialize, T1: Serialize, T2: Serialize, T3: Serialize, T4: Serialize, T5: Serialize, T6: Serialize, T7: Serialize, T8: Serialize, T9: Serialize, T10: Serialize, T11: Serialize, T12: Serialize, T13: Serialize, T14: Serialize, T15: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for Option<T>

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 0]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 1]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 2]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 3]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 4]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 5]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 6]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 7]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 8]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 9]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 10]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 11]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 12]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 13]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 14]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 15]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 16]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 17]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 18]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 19]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 20]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 21]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 22]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 23]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 24]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 25]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 26]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 27]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 28]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 29]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 30]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 31]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T; 32]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for [T]

where T: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for Box<T>

where T: Serialize + ?Sized,

Available on crate features std or alloc only.

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for BinaryHeap<T>

where T: Serialize + Ord,

Available on crate features std or collections only.

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for BTreeSet<T>

where T: Serialize + Ord,

Available on crate features std or collections only.

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for LinkedList<T>

where T: Serialize,

Available on crate features std or collections only.

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for VecDeque<T>

where T: Serialize,

Available on crate features std or collections only.

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for Rc<T>

where T: Serialize,

Available on crate features std or alloc only.

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for Arc<T>

where T: Serialize,

Available on crate features std or alloc only.

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for Vec<T>

where T: Serialize,

Available on crate features std or collections only.

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T> Serialize for PhantomData<T>

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T, E> Serialize for Result<T, E>

where T: Serialize, E: Serialize,

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

impl<T, H> Serialize for HashSet<T, H>

where T: Serialize + Eq + Hash, H: BuildHasher,

Available on crate feature std only.

fn serialize<S>( &self, serializer: &mut S, ) -> Result<(), <S as Serializer>::Error>

where S: Serializer,

Implementors

impl Serialize for ByteBuf

impl<'a> Serialize for Bytes<'a>