Trait serde::ser::Serialize

pub trait Serialize {
    // Required method
    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()
    }
}

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl Serialize for IpAddr

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 bool

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 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 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 i128

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 str

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 u128

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

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

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 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 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 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 AtomicI64

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 AtomicU64

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 Duration

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 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 SystemTime

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 NonZeroI128

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 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 NonZeroU128

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<'a> Serialize for Arguments<'a>

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

where S: Serializer,

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

where T: ?Sized + Serialize + ToOwned,

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

where S: Serializer,

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

where T: ?Sized + Serialize,

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

where S: Serializer,

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

where T: ?Sized + 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 RangeFrom<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<Idx> Serialize for RangeTo<Idx>

where Idx: 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, 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, V: 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<T> Serialize for Bound<T>

where T: Serialize,

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> 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 (T,)

where T: Serialize,

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

where S: Serializer,

impl<T> Serialize for Box<T>

where T: ?Sized + Serialize,

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

where S: Serializer,

impl<T> Serialize for BinaryHeap<T>

where T: Serialize,

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

where S: Serializer,

impl<T> Serialize for BTreeSet<T>

where T: Serialize,

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 VecDeque<T>

where T: Serialize,

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

where S: Serializer,

impl<T> Serialize for Rc<T>

where T: ?Sized + 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> Serialize for RcWeak<T>

where T: ?Sized + 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> Serialize for Arc<T>

where T: ?Sized + 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<T> Serialize for ArcWeak<T>

where T: ?Sized + 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> 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 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: ?Sized + 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<T> Serialize for PhantomData<T>

where T: ?Sized,

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

where S: Serializer,

impl<T> Serialize for Saturating<T>

where T: Serialize,

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 Mutex<T>

where T: ?Sized + Serialize,

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

where S: Serializer,

impl<T> Serialize for RwLock<T>

where T: ?Sized + 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<T, H> Serialize for HashSet<T, H>

where T: Serialize,

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

where S: Serializer,

Implementors

impl<R> Serialize for BitIdx<R>

where R: BitRegister,

impl<T, O> Serialize for Domain<'_, Const, T, O>

where T: BitStore, O: BitOrder, T::Mem: Serialize,

impl<T, O> Serialize for BitArray<T, O>

where T: BitStore, O: BitOrder, T::Mem: Serialize,

impl<T, O> Serialize for BitBox<T, O>

where T: BitStore, O: BitOrder, BitSlice<T, O>: Serialize,

impl<T, O> Serialize for BitSlice<T, O>

where T: BitStore, O: BitOrder, T::Mem: Serialize,

impl<T, O> Serialize for BitVec<T, O>

where T: BitStore, O: BitOrder, BitSlice<T, O>: Serialize,

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

where T: BitStore, O: BitOrder, T::Mem: Serialize,

impl<T, S> Serialize for BoundedBTreeSet<T, S>

where T: Serialize,

impl<T, S> Serialize for BoundedVec<T, S>

where T: Serialize,

impl<T, S> Serialize for WeakBoundedVec<T, S>

where T: Serialize,

impl Serialize for ByteSize

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

where K: EntityRef, V: Serialize,

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

where K: EntityRef, V: Clone + PartialEq + Serialize,

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

where K: EntityRef + Serialize, V: SparseMapValue<K> + Serialize,

impl<T> Serialize for PackedOption<T>

where T: Serialize + ReservedValue,

impl<T> Serialize for ListPool<T>

where T: Serialize + EntityRef + ReservedValue,

impl<T: EntityRef + ReservedValue> Serialize for EntityList<T>

impl<C> Serialize for Signature<C>

where C: PrimeCurve, MaxSize<C>: ArrayLength<u8>, <FieldBytesSize<C> as Add>::Output: Add<MaxOverhead> + ArrayLength<u8>,

impl<C> Serialize for Signature<C>

where C: PrimeCurve, SignatureSize<C>: ArrayLength<u8>,

impl<C> Serialize for NonZeroScalar<C>

where C: CurveArithmetic,

impl<C> Serialize for ScalarPrimitive<C>

where C: Curve,

impl<C> Serialize for PublicKey<C>

where C: AssociatedOid + CurveArithmetic, AffinePoint<C>: FromEncodedPoint<C> + ToEncodedPoint<C>, FieldBytesSize<C>: ModulusSize,

impl<P> Serialize for NonIdentity<P>

where P: Serialize,

impl Serialize for RuntimeMetadata

impl Serialize for RuntimeMetadataDeprecated

impl Serialize for StorageEntryModifier

impl Serialize for StorageHasher

impl Serialize for OpaqueMetadata

impl Serialize for RuntimeMetadataPrefixed

impl Serialize for RuntimeMetadataV14

impl Serialize for RuntimeMetadataV15

impl<T: Form> Serialize for StorageEntryType<T>

where T::Type: Serialize, T::String: Serialize,

impl<T: Form> Serialize for ExtrinsicMetadata<T>

where T::Type: Serialize, T::String: Serialize,

impl<T: Form> Serialize for PalletCallMetadata<T>

where T::Type: Serialize, T::String: Serialize,

impl<T: Form> Serialize for PalletConstantMetadata<T>

where T::Type: Serialize, T::String: Serialize,

impl<T: Form> Serialize for PalletErrorMetadata<T>

where T::Type: Serialize,

impl<T: Form> Serialize for PalletEventMetadata<T>

where T::Type: Serialize,

impl<T: Form> Serialize for PalletMetadata<T>

where T::Type: Serialize, T::String: Serialize,

impl<T: Form> Serialize for PalletStorageMetadata<T>

where T::Type: Serialize, T::String: Serialize,

impl<T: Form> Serialize for SignedExtensionMetadata<T>

where T::Type: Serialize, T::String: Serialize,

impl<T: Form> Serialize for StorageEntryMetadata<T>

where T::Type: Serialize, T::String: Serialize,

impl<T: Form> Serialize for CustomMetadata<T>

where T::Type: Serialize, T::String: Serialize,

impl<T: Form> Serialize for CustomValueMetadata<T>

where T::Type: Serialize, T::String: Serialize,

impl<T: Form> Serialize for ExtrinsicMetadata<T>

where T::Type: Serialize, T::String: Serialize,

impl<T: Form> Serialize for OuterEnums<T>

where T::Type: Serialize, T::String: Serialize,

impl<T: Form> Serialize for PalletMetadata<T>

where T::Type: Serialize, T::String: Serialize,

impl<T: Form> Serialize for RuntimeApiMetadata<T>

where T::Type: Serialize, T::String: Serialize,

impl<T: Form> Serialize for RuntimeApiMethodMetadata<T>

where T::Type: Serialize, T::String: Serialize,

impl<T: Form> Serialize for RuntimeApiMethodParamMetadata<T>

where T::Type: Serialize, T::String: Serialize,

impl<T: Form> Serialize for SignedExtensionMetadata<T>

where T::Type: Serialize, T::String: Serialize,

impl Serialize for DispatchClass

impl<T> Serialize for WrapperOpaque<T>

where T: Serialize,

impl Serialize for Phase

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

where E: Serialize + Parameter + Member, T: Serialize,

impl<T: Config> Serialize for GenesisConfig<T>

impl Serialize for ConnectionId

impl Serialize for ErrorCode

impl Serialize for TwoPointZero

impl<'a> Serialize for Id<'a>

impl<'a> Serialize for SubscriptionId<'a>

impl<'a> Serialize for ErrorObject<'a>

impl<'a> Serialize for NotificationSer<'a>

impl<'a> Serialize for Request<'a>

impl<'a> Serialize for RequestSer<'a>

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

where T: Serialize,

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

where T: Serialize + Clone,

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

where T: Serialize,

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

where T: Serialize,

impl Serialize for AffinePoint

impl Serialize for Scalar

impl Serialize for PublicKey

impl Serialize for PeerId

impl Serialize for Multiaddr

impl<'de> Serialize for Mnemonic

impl<T> Serialize for Compact<T>

where T: Serialize,

impl Serialize for ErasureChunk

impl Serialize for Proof

impl Serialize for BlockData

impl Serialize for HeadData

impl Serialize for Id

impl Serialize for ValidationCode

impl Serialize for PvfExecKind

impl Serialize for PvfPrepKind

impl Serialize for ExecutorParam

impl Serialize for AsyncBackingParams

impl Serialize for ExecutorParams

impl Serialize for ApprovalVotingParams

impl Serialize for ChunkIndex

impl Serialize for ValidatorIndex

impl<BlockNumber> Serialize for SchedulerParams<BlockNumber>

where BlockNumber: Serialize,

impl Serialize for H128

impl Serialize for H160

impl Serialize for H256

impl Serialize for H384

impl Serialize for H512

impl Serialize for H768

impl Serialize for U128

impl Serialize for U256

impl Serialize for U512

impl Serialize for ChainType

impl<BlockNumber, T> Serialize for Forks<BlockNumber, T>

where BlockNumber: Serialize + Ord, T: Serialize + Group,

impl Serialize for ImportedAux

impl Serialize for Endpoint

impl Serialize for PeerEndpoint

impl Serialize for MultiaddrWithPeerId

impl Serialize for NetworkState

impl Serialize for NotConnectedPeer

impl Serialize for Peer

impl Serialize for NodeRole

impl Serialize for BlockStats

impl Serialize for Health

impl<Hash> Serialize for ExtrinsicOrHash<Hash>

where Hash: Serialize,

impl<Hash> Serialize for ReadProof<Hash>

where Hash: Serialize,

impl<Hash, Number> Serialize for PeerInfo<Hash, Number>

where Hash: Serialize, Number: Serialize,

impl<Number> Serialize for SyncState<Number>

where Number: Serialize,

impl Serialize for MethodResponse

impl Serialize for RuntimeEvent

impl Serialize for MethodResult

impl Serialize for ChainHeadRuntimeVersion

impl Serialize for ErrorEvent

impl Serialize for MethodResponseStarted

impl Serialize for OperationBodyDone

impl Serialize for OperationCallDone

impl Serialize for OperationError

impl Serialize for OperationId

impl Serialize for OperationStorageItems

impl Serialize for RuntimeVersionEvent

impl Serialize for MethodResultErr

impl Serialize for MethodResultOk

impl Serialize for TransactionDropped

impl Serialize for TransactionError

impl<Hash> Serialize for FollowEvent<Hash>

where Hash: Serialize,

impl<Hash> Serialize for TransactionEvent<Hash>

where Hash: Serialize + Clone,

impl<Hash> Serialize for BestBlockChanged<Hash>

where Hash: Serialize,

impl<Hash> Serialize for Finalized<Hash>

where Hash: Serialize,

impl<Hash> Serialize for TransactionBlock<Hash>

where Hash: Serialize,

impl<Hash: Serialize> Serialize for Initialized<Hash>

impl<Hash: Serialize> Serialize for NewBlock<Hash>

impl Serialize for Metric

impl Serialize for HwBench

impl Serialize for Requirement

impl Serialize for Requirements

impl Serialize for ConnectionMessage

impl Serialize for SysInfo

impl Serialize for TelemetryEndpoints

impl Serialize for Values

impl<Hash, BlockHash> Serialize for TransactionStatus<Hash, BlockHash>

where Hash: Serialize, BlockHash: Serialize,

impl Serialize for TypeDefPrimitive

impl Serialize for MetaForm

impl Serialize for PortableForm

impl Serialize for PortableRegistry

impl Serialize for PortableType

impl<'a, T: 'a> Serialize for Symbol<'a, T>

impl<T> Serialize for Interner<T>

where T: Serialize,

impl<T> Serialize for UntrackedSymbol<T>

impl<T: Form> Serialize for TypeDef<T>

where T::Type: Serialize, T::String: Serialize,

impl<T: Form> Serialize for Field<T>

where T::Type: Serialize, T::String: Serialize,

impl<T: Form> Serialize for Path<T>

where T::Type: Serialize, T::String: Serialize,

impl<T: Form> Serialize for Type<T>

where T::Type: Serialize, T::String: Serialize,

impl<T: Form> Serialize for TypeDefArray<T>

where T::Type: Serialize,

impl<T: Form> Serialize for TypeDefBitSequence<T>

where T::Type: Serialize,

impl<T: Form> Serialize for TypeDefCompact<T>

where T::Type: Serialize,

impl<T: Form> Serialize for TypeDefComposite<T>

where T::Type: Serialize, T::String: Serialize,

impl<T: Form> Serialize for TypeDefSequence<T>

where T::Type: Serialize,

impl<T: Form> Serialize for TypeDefTuple<T>

where T::Type: Serialize, T::String: Serialize,

impl<T: Form> Serialize for TypeDefVariant<T>

where T::Type: Serialize, T::String: Serialize,

impl<T: Form> Serialize for TypeParameter<T>

where T::Type: Serialize, T::String: Serialize,

impl<T: Form> Serialize for Variant<T>

where T::Type: Serialize, T::String: Serialize,

impl<Size> Serialize for EncodedPoint<Size>

where Size: ModulusSize,

impl Serialize for ByteBuf

impl Serialize for Bytes

impl<const N: usize> Serialize for ByteArray<N>

impl Serialize for Value

impl Serialize for Map<String, Value>

impl Serialize for Number

impl Serialize for RawValue

impl<const N: usize, const UPPERCASE: bool> Serialize for HexOrBin<N, UPPERCASE>

impl<const UPPERCASE: bool> Serialize for HexOrBin<UPPERCASE>

impl Serialize for Public

impl Serialize for Public

impl Serialize for Public

impl Serialize for ArithmeticError

impl Serialize for FixedI128

impl Serialize for FixedI64

impl Serialize for FixedU128

impl Serialize for FixedU64

impl Serialize for PerU16

impl Serialize for Perbill

impl Serialize for Percent

impl Serialize for Permill

impl Serialize for Perquintill

impl Serialize for AllowedSlots

impl Serialize for BabeEpochConfiguration

impl<N> Serialize for ConsensusLog<N>

where N: Serialize + Codec,

impl<N> Serialize for ScheduledChange<N>

where N: Serialize,

impl Serialize for Slot

impl Serialize for StorageKind

impl Serialize for AccountId32

impl Serialize for CryptoTypeId

impl Serialize for KeyTypeId

impl Serialize for Duration

impl Serialize for Timestamp

impl Serialize for Bytes

impl Serialize for OpaquePeerId

impl Serialize for Public

impl<const N: usize, SubTag> Serialize for PublicBytes<N, SubTag>

where Self: CryptoType,

impl<const N: usize, SubTag> Serialize for SignatureBytes<N, SubTag>

where Self: CryptoType,

impl Serialize for NumberOrHex

impl Serialize for TraceBlockResponse

impl Serialize for BlockTrace

impl Serialize for Data

impl Serialize for Event

impl Serialize for Span

impl Serialize for TraceError

impl<T> Serialize for ListOrValue<T>

where T: Serialize,

impl Serialize for DispatchError

impl Serialize for MultiSignature

impl Serialize for MultiSigner

impl Serialize for RuntimeString

impl Serialize for TokenError

impl Serialize for TransactionalError

impl Serialize for DigestItem

impl Serialize for Era

impl Serialize for DispatchError

impl Serialize for TrieError

impl Serialize for InvalidTransaction

impl Serialize for TransactionValidityError

impl Serialize for UnknownTransaction

impl Serialize for Digest

impl Serialize for ModuleError

impl Serialize for AnySignature

impl Serialize for Justifications

impl Serialize for ModuleError

impl Serialize for OpaqueExtrinsic

impl Serialize for TestSignature

impl Serialize for UintAuthorityId

impl Serialize for BlakeTwo256

impl Serialize for Keccak256

impl<Address: Encode, Signature: Encode, Call: Encode, Extra: SignedExtension> Serialize for UncheckedExtrinsic<Address, Call, Signature, Extra>

impl<Block> Serialize for SignedBlock<Block>

where Block: Serialize,

impl<Call, Extra> Serialize for TestXt<Call, Extra>

where TestXt<Call, Extra>: Encode,

impl<Header, Extrinsic> Serialize for Block<Header, Extrinsic>

where Header: Serialize, Extrinsic: Serialize,

impl<Number: Copy + Into<U256> + TryFrom<U256>, Hash: HashT> Serialize for Header<Number, Hash>

where Hash::Output: Serialize,

impl<T, D: Get<T>> Serialize for TypeWithDefault<T, D>

where T: Serialize,

impl<Xt> Serialize for Block<Xt>

where Xt: Serialize,

impl<Xt: Encode> Serialize for ExtrinsicWrapper<Xt>

impl<AccountId> Serialize for StakerStatus<AccountId>

where AccountId: Serialize,

impl Serialize for PrefixedStorageKey

impl Serialize for StorageData

impl Serialize for StorageKey

impl<Hash> Serialize for StorageChangeSet<Hash>

where Hash: Serialize,

impl Serialize for RuntimeVersion

impl Serialize for Weight

impl Serialize for AssetId

impl Serialize for AssetInstance

impl Serialize for BodyId

impl Serialize for BodyPart

impl Serialize for Fungibility

impl Serialize for Junction

impl Serialize for Junctions

impl Serialize for MultiAssetFilter

impl Serialize for NetworkId

impl Serialize for WildFungibility

impl Serialize for WildMultiAsset

impl Serialize for AssetId

impl Serialize for AssetInstance

impl Serialize for BodyId

impl Serialize for BodyPart

impl Serialize for Fungibility

impl Serialize for Junction

impl Serialize for Junctions

impl Serialize for MultiAssetFilter

impl Serialize for NetworkId

impl Serialize for WildFungibility

impl Serialize for WildMultiAsset

impl Serialize for AssetFilter

impl Serialize for AssetInstance

impl Serialize for Fungibility

impl Serialize for Junction

impl Serialize for Junctions

impl Serialize for NetworkId

impl Serialize for WildAsset

impl Serialize for WildFungibility

impl Serialize for MultiAsset

impl Serialize for MultiAssets

impl Serialize for MultiLocation

impl Serialize for MultiAsset

impl Serialize for MultiAssets

impl Serialize for MultiLocation

impl Serialize for Asset

impl Serialize for AssetId

impl Serialize for Assets

impl Serialize for Location

impl Serialize for Value

impl Serialize for Map<String, Value>

impl Serialize for Datetime

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

impl Serialize for OptLevel

impl Serialize for FlagValue

impl Serialize for Initializer

impl Serialize for MemoryInitialization

impl Serialize for MemoryStyle

impl Serialize for ModuleType

impl Serialize for TableInitialization

impl Serialize for TableStyle

impl Serialize for AnyfuncIndex

impl Serialize for FilePos

impl Serialize for FunctionLoc

impl Serialize for FunctionType

impl Serialize for InstructionAddressMap

impl Serialize for MemoryInitializer

impl Serialize for MemoryPlan

impl Serialize for Module

impl Serialize for ModuleTypes

impl Serialize for StackMap

impl Serialize for StackMapInformation

impl Serialize for StaticMemoryInitializer

impl Serialize for TableInitializer

impl Serialize for TablePlan

impl Serialize for Tunables

impl Serialize for WasmFunctionInfo

impl Serialize for CompiledModuleInfo

impl Serialize for EntityIndex

impl Serialize for EntityType

impl Serialize for GlobalInit

impl Serialize for WasmType

impl Serialize for DataIndex

impl Serialize for DefinedFuncIndex

impl Serialize for DefinedGlobalIndex

impl Serialize for DefinedMemoryIndex

impl Serialize for DefinedTableIndex

impl Serialize for ElemIndex

impl Serialize for FuncIndex

impl Serialize for Global

impl Serialize for GlobalIndex

impl Serialize for Memory

impl Serialize for MemoryIndex

impl Serialize for OwnedMemoryIndex

impl Serialize for SignatureIndex

impl Serialize for Table

impl Serialize for TableIndex

impl Serialize for Tag

impl Serialize for TagIndex

impl Serialize for TypeIndex

impl Serialize for WasmFuncType