Trait serde::Serialize

pub trait Serialize {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer;
}

A data structure that can be serialized into any data format supported by Serde.

Serde provides Serialize implementations for many Rust primitive and standard library types. The complete list is here. All of these can be serialized using Serde out of the box.

Additionally, Serde provides a procedural macro called serde_derive to automatically generate Serialize implementations for structs and enums in your program. See the derive section of the manual for how to use this.

In rare cases it may be necessary to implement Serialize manually for some type in your program. See the Implementing Serialize section of the manual for more about this.

Third-party crates may provide Serialize implementations for types that they expose. For example the linked-hash-map crate provides a LinkedHashMap<K, V> type that is serializable by Serde because the crate provides an implementation of Serialize for it.

Required Methods

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

Serialize this value into the given Serde serializer.

See the Implementing Serialize section of the manual for more information about how to implement this method.

use serde::ser::{Serialize, SerializeStruct, Serializer};

struct Person {
    name: String,
    age: u8,
    phones: Vec<String>,
}

// This is what #[derive(Serialize)] would generate.
impl Serialize for Person {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut s = serializer.serialize_struct("Person", 3)?;
        s.serialize_field("name", &self.name)?;
        s.serialize_field("age", &self.age)?;
        s.serialize_field("phones", &self.phones)?;
        s.end()
    }
}

Implementations on Foreign Types

impl Serialize for bool

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

impl Serialize for isize

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

impl Serialize for i8

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

impl Serialize for i16

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

impl Serialize for i32

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

impl Serialize for i64

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

impl Serialize for usize

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

impl Serialize for u8

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

impl Serialize for u16

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

impl Serialize for u32

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

impl Serialize for u64

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

impl Serialize for f32

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

impl Serialize for f64

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

impl Serialize for char

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

impl Serialize for i128

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

impl Serialize for u128

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

impl Serialize for str

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

impl Serialize for String

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

impl<'a> Serialize for Arguments<'a>

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

impl Serialize for CStr

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

impl Serialize for CString

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

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

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

impl<T: ?Sized> Serialize for PhantomData<T>

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

impl<T> Serialize for [T; 0]

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

impl<T> Serialize for [T; 1] where
    T: Serialize, 

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

impl<T> Serialize for [T; 2] where
    T: Serialize, 

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

impl<T> Serialize for [T; 3] where
    T: Serialize, 

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

impl<T> Serialize for [T; 4] where
    T: Serialize, 

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

impl<T> Serialize for [T; 5] where
    T: Serialize, 

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

impl<T> Serialize for [T; 6] where
    T: Serialize, 

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

impl<T> Serialize for [T; 7] where
    T: Serialize, 

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

impl<T> Serialize for [T; 8] where
    T: Serialize, 

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

impl<T> Serialize for [T; 9] where
    T: Serialize, 

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

impl<T> Serialize for [T; 10] where
    T: Serialize, 

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

impl<T> Serialize for [T; 11] where
    T: Serialize, 

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

impl<T> Serialize for [T; 12] where
    T: Serialize, 

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

impl<T> Serialize for [T; 13] where
    T: Serialize, 

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

impl<T> Serialize for [T; 14] where
    T: Serialize, 

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

impl<T> Serialize for [T; 15] where
    T: Serialize, 

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

impl<T> Serialize for [T; 16] where
    T: Serialize, 

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

impl<T> Serialize for [T; 17] where
    T: Serialize, 

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

impl<T> Serialize for [T; 18] where
    T: Serialize, 

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

impl<T> Serialize for [T; 19] where
    T: Serialize, 

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

impl<T> Serialize for [T; 20] where
    T: Serialize, 

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

impl<T> Serialize for [T; 21] where
    T: Serialize, 

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

impl<T> Serialize for [T; 22] where
    T: Serialize, 

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

impl<T> Serialize for [T; 23] where
    T: Serialize, 

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

impl<T> Serialize for [T; 24] where
    T: Serialize, 

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

impl<T> Serialize for [T; 25] where
    T: Serialize, 

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

impl<T> Serialize for [T; 26] where
    T: Serialize, 

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

impl<T> Serialize for [T; 27] where
    T: Serialize, 

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

impl<T> Serialize for [T; 28] where
    T: Serialize, 

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

impl<T> Serialize for [T; 29] where
    T: Serialize, 

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

impl<T> Serialize for [T; 30] where
    T: Serialize, 

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

impl<T> Serialize for [T; 31] where
    T: Serialize, 

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

impl<T> Serialize for [T; 32] where
    T: Serialize, 

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

impl<T> Serialize for [T] where
    T: Serialize, 

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

impl<T> Serialize for BinaryHeap<T> where
    T: Serialize + Ord, 

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

impl<T> Serialize for BTreeSet<T> where
    T: Serialize + Ord, 

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

impl<T, H> Serialize for HashSet<T, H> where
    T: Serialize + Eq + Hash,
    H: BuildHasher, 

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

impl<T> Serialize for LinkedList<T> where
    T: Serialize, 

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

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

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

impl<T> Serialize for VecDeque<T> where
    T: Serialize, 

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

impl<Idx> Serialize for Range<Idx> where
    Idx: Serialize, 

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

impl<Idx> Serialize for RangeInclusive<Idx> where
    Idx: Serialize, 

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

impl<T> Serialize for Bound<T> where
    T: Serialize, 

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

impl Serialize for ()

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

impl<T0> Serialize for (T0,) where
    T0: Serialize, 

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

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

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::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: S) -> Result<S::Ok, S::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: S) -> Result<S::Ok, S::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: S) -> Result<S::Ok, S::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: S) -> Result<S::Ok, S::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: S) -> Result<S::Ok, S::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: S) -> Result<S::Ok, S::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: S) -> Result<S::Ok, S::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: S) -> Result<S::Ok, S::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: S) -> Result<S::Ok, S::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: S) -> Result<S::Ok, S::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: S) -> Result<S::Ok, S::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: S) -> Result<S::Ok, S::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: S) -> Result<S::Ok, S::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: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

impl<K, V> Serialize for BTreeMap<K, V> where
    K: Serialize + Ord,
    V: Serialize, 

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

impl<K, V, H> Serialize for HashMap<K, V, H> where
    K: Serialize + Eq + Hash,
    V: Serialize,
    H: BuildHasher, 

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

impl<'a, T: ?Sized> Serialize for &'a T where
    T: Serialize, 

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

impl<'a, T: ?Sized> Serialize for &'a mut T where
    T: Serialize, 

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

impl<T: ?Sized> Serialize for Box<T> where
    T: Serialize, 

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

impl<T: ?Sized> Serialize for Rc<T> where
    T: Serialize, 

This impl requires the "rc" Cargo feature of Serde.

Serializing a data structure containing Rc will serialize a copy of the contents of the Rc each time the Rc is referenced within the data structure. Serialization will not attempt to deduplicate these repeated data.

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

impl<T: ?Sized> Serialize for Arc<T> where
    T: Serialize, 

This impl requires the "rc" Cargo feature of Serde.

Serializing a data structure containing Arc will serialize a copy of the contents of the Arc each time the Arc is referenced within the data structure. Serialization will not attempt to deduplicate these repeated data.

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

impl<'a, T: ?Sized> Serialize for Cow<'a, T> where
    T: Serialize + ToOwned, 

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

impl<T: ?Sized> Serialize for RcWeak<T> where
    T: Serialize, 

This impl requires the "rc" Cargo feature of Serde.

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

impl<T: ?Sized> Serialize for ArcWeak<T> where
    T: Serialize, 

This impl requires the "rc" Cargo feature of Serde.

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

impl Serialize for NonZeroU8

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

impl Serialize for NonZeroU16

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

impl Serialize for NonZeroU32

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

impl Serialize for NonZeroU64

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

impl Serialize for NonZeroUsize

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

impl Serialize for NonZeroI8

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

impl Serialize for NonZeroI16

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

impl Serialize for NonZeroI32

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

impl Serialize for NonZeroI64

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

impl Serialize for NonZeroIsize

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

impl Serialize for NonZeroU128

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

impl Serialize for NonZeroI128

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

impl<T> Serialize for Cell<T> where
    T: Serialize + Copy, 

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

impl<T> Serialize for RefCell<T> where
    T: Serialize, 

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

impl<T> Serialize for Mutex<T> where
    T: Serialize, 

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

impl<T> Serialize for RwLock<T> where
    T: Serialize, 

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

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

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

impl Serialize for Duration

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

impl Serialize for SystemTime

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

impl Serialize for IpAddr

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

impl Serialize for Ipv4Addr

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

impl Serialize for Ipv6Addr

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

impl Serialize for SocketAddr

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

impl Serialize for SocketAddrV4

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

impl Serialize for SocketAddrV6

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

impl Serialize for Path

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

impl Serialize for PathBuf

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

impl Serialize for OsStr

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

impl Serialize for OsString

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

impl<T> Serialize for Wrapping<T> where
    T: Serialize, 

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

impl<T> Serialize for Reverse<T> where
    T: Serialize, 

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

impl Serialize for AtomicBool

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

impl Serialize for AtomicI8

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

impl Serialize for AtomicI16

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

impl Serialize for AtomicI32

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

impl Serialize for AtomicIsize

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

impl Serialize for AtomicU8

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

impl Serialize for AtomicU16

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

impl Serialize for AtomicU32

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

impl Serialize for AtomicUsize

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

impl Serialize for AtomicI64

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

impl Serialize for AtomicU64

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

Implementors

impl<T> Serialize for Data<T> where
    T: Serialize, 

impl<T> Serialize for Form<T> where
    T: Serialize, 

impl<T: Serialize> Serialize for Json<T>

impl Serialize for CodeId

impl Serialize for DebugId

impl Serialize for Exception

impl Serialize for Error

impl Serialize for Cause

impl Serialize for Bytes

impl Serialize for Conflicts

impl Serialize for DefaultOperator

impl Serialize for ExpandWildcards

impl Serialize for Format

impl Serialize for Health

impl Serialize for Level

impl Serialize for OpType

impl Serialize for Refresh

impl Serialize for SearchType

impl Serialize for Size

impl Serialize for SuggestMode

impl Serialize for Time

impl Serialize for Type

impl Serialize for VersionType

impl Serialize for WaitForEvents

impl Serialize for WaitForStatus

impl Serialize for TrackTotalHits

impl Serialize for SourceFilter

impl Serialize for Slices

impl<'a> Serialize for Country<'a>

impl<'a> Serialize for City<'a>

impl<'a> Serialize for Isp<'a>

impl<'a> Serialize for ConnectionType<'a>

impl Serialize for AnonymousIp

impl Serialize for DensityIncome

impl<'a> Serialize for Domain<'a>

impl<'a> Serialize for Asn<'a>

impl<'a> Serialize for City<'a>

impl<'a> Serialize for Continent<'a>

impl<'a> Serialize for Country<'a>

impl<'a> Serialize for Location<'a>

impl<'a> Serialize for Postal<'a>

impl<'a> Serialize for RepresentedCountry<'a>

impl<'a> Serialize for Subdivision<'a>

impl Serialize for Traits

impl Serialize for AttachmentMeta

impl Serialize for AdmSuggestion

impl Serialize for TracingJsonEvent

impl Serialize for LoggingSettings

impl Serialize for LogFormat

impl Serialize for DirectiveWrapper

impl Serialize for SuggestionProviderConfig

impl Serialize for MultiplexerConfig

impl Serialize for RedisCacheConfig

impl Serialize for MemoryCacheConfig

impl Serialize for RemoteSettingsConfig

impl Serialize for TimeoutConfig

impl Serialize for FixedConfig

impl Serialize for KeywordFilterConfig

impl Serialize for StealthConfig

impl Serialize for ClientVariantSwitchConfig

impl Serialize for SuggestionProviderSettings

impl Serialize for Settings

impl Serialize for HttpSettings

impl Serialize for CacheType

impl Serialize for AdmRsSettings

impl Serialize for WikiFruitSettings

impl Serialize for RedisSettings

impl Serialize for RemoteSettingsGlobalSettings

impl Serialize for LocationSettings

impl Serialize for MetricsSettings

impl Serialize for SentrySettings

impl Serialize for ProviderSettings

impl Serialize for ElasticsearchSettings

impl Serialize for ElasticsearchConnection

impl Serialize for ProviderDetails

impl Serialize for ProviderAvailability

impl Serialize for FormFactor

impl Serialize for OsFamily

impl Serialize for Browser

impl Serialize for DeviceInfo

impl Serialize for Proportion

impl Serialize for SuggestionRequest

impl Serialize for Suggestion

impl Serialize for CheckStatus

impl Serialize for HeartbeatResponse

impl Serialize for ListResponse

impl<'a> Serialize for SuggestResponse<'a>

impl<'a> Serialize for SuggestionWrapper<'a>

impl Serialize for WikipediaDocument

impl Serialize for Record

impl Serialize for AttachmentMetadata

impl Serialize for Collection

impl Serialize for Value

impl Serialize for PrettyConfig

impl Serialize for Map

impl Serialize for Extensions

impl Serialize for Auth

impl Serialize for Dsn

impl Serialize for ProjectId

impl<T> Serialize for Values<T> where
    T: Serialize, 

impl Serialize for LogEntry

impl Serialize for Frame

impl Serialize for TemplateInfo

impl Serialize for Stacktrace

impl Serialize for ThreadId

impl Serialize for Addr

impl Serialize for RegVal

impl Serialize for Thread

impl Serialize for CError

impl Serialize for MachException

impl Serialize for PosixSignal

impl Serialize for MechanismMeta

impl Serialize for Mechanism

impl Serialize for Exception

impl Serialize for Level

impl Serialize for Breadcrumb

impl Serialize for IpAddress

impl Serialize for User

impl Serialize for Request

impl Serialize for SystemSdkInfo

impl Serialize for DebugImage

impl Serialize for AppleDebugImage

impl Serialize for SymbolicDebugImage

impl Serialize for ProguardDebugImage

impl Serialize for WasmDebugImage

impl Serialize for DebugMeta

impl Serialize for ClientSdkInfo

impl Serialize for ClientSdkPackage

impl Serialize for Context

impl Serialize for Orientation

impl Serialize for DeviceContext

impl Serialize for OsContext

impl Serialize for RuntimeContext

impl Serialize for AppContext

impl Serialize for BrowserContext

impl Serialize for GpuContext

impl Serialize for SpanId

impl Serialize for TraceId

impl Serialize for TraceContext

impl<'a> Serialize for Event<'a>

impl Serialize for Span

impl Serialize for SpanStatus

impl<'a> Serialize for Transaction<'a>

impl Serialize for SessionStatus

impl<'a> Serialize for SessionAttributes<'a>

impl<'a> Serialize for SessionUpdate<'a>

impl Serialize for SessionAggregateItem

impl<'a> Serialize for SessionAggregates<'a>

impl Serialize for Map<String, Value>

impl Serialize for Value

impl Serialize for Number

impl<'a, T, U> Serialize for SerializeAsWrap<'a, T, U> where
    T: ?Sized,
    U: ?Sized,
    U: SerializeAs<T>, 

impl Serialize for Map<String, Value>

impl Serialize for Value

impl Serialize for Datetime

impl<T: Serialize> Serialize for Spanned<T>

impl Serialize for MozLogMessage

impl<'a> Serialize for SerializeFieldMap<'a, Event<'_>>

impl<'a> Serialize for SerializeFieldMap<'a, Attributes<'_>>

impl<'a> Serialize for SerializeFieldMap<'a, Record<'_>>

impl Serialize for SerializeField

impl<'a> Serialize for SerializeFieldSet<'a>

impl<'a> Serialize for SerializeLevel<'a>

impl<'a> Serialize for SerializeId<'a>

impl<'a> Serialize for SerializeMetadata<'a>

impl<'a> Serialize for SerializeEvent<'a>

impl<'a> Serialize for SerializeAttributes<'a>

impl<'a> Serialize for SerializeRecord<'a>

impl<S> Serialize for Host<S> where
    S: Serialize, 

impl Serialize for Url

impl Serialize for Uuid

impl Serialize for Hyphenated

impl Serialize for Simple

impl Serialize for Urn

impl Serialize for Braced