Trait serde::ser::Serialize

pub trait Serialize {
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::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::Error> where
    S: Serializer, 

Serializes this value into this serializer.

Implementations on Foreign Types

impl Serialize for bool

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

impl Serialize for isize

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

impl Serialize for i8

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

impl Serialize for i16

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

impl Serialize for i32

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

impl Serialize for i64

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

impl Serialize for usize

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

impl Serialize for u8

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

impl Serialize for u16

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

impl Serialize for u32

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

impl Serialize for u64

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

impl Serialize for f32

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

impl Serialize for f64

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

impl Serialize for char

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

impl Serialize for str

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

impl Serialize for String

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Serialize for ()

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

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

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

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

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

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

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

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

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

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: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error>

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: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error>

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: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error>

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: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error>

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: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error>

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: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error>

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: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error>

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: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Serialize for Path

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

impl Serialize for PathBuf

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

Implementors

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

• impl Serialize for ByteBuf