Trait serde::de::Deserialize

pub trait Deserialize: Sized {
    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
    where
        D: Deserializer;
}

Deserialize represents a type that can be deserialized.

Required Methods

fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error> where
    D: Deserializer, 

Deserialize this value given this Deserializer.

Implementations on Foreign Types

impl Deserialize for ()

fn deserialize<D>(deserializer: &mut D) -> Result<(), D::Error> where     D: Deserializer,

impl Deserialize for bool

fn deserialize<D>(deserializer: &mut D) -> Result<bool, D::Error> where     D: Deserializer,

impl Deserialize for isize

fn deserialize<D>(deserializer: &mut D) -> Result<isize, D::Error> where     D: Deserializer,

impl Deserialize for i8

fn deserialize<D>(deserializer: &mut D) -> Result<i8, D::Error> where     D: Deserializer,

impl Deserialize for i16

fn deserialize<D>(deserializer: &mut D) -> Result<i16, D::Error> where     D: Deserializer,

impl Deserialize for i32

fn deserialize<D>(deserializer: &mut D) -> Result<i32, D::Error> where     D: Deserializer,

impl Deserialize for i64

fn deserialize<D>(deserializer: &mut D) -> Result<i64, D::Error> where     D: Deserializer,

impl Deserialize for usize

fn deserialize<D>(deserializer: &mut D) -> Result<usize, D::Error> where     D: Deserializer,

impl Deserialize for u8

fn deserialize<D>(deserializer: &mut D) -> Result<u8, D::Error> where     D: Deserializer,

impl Deserialize for u16

fn deserialize<D>(deserializer: &mut D) -> Result<u16, D::Error> where     D: Deserializer,

impl Deserialize for u32

fn deserialize<D>(deserializer: &mut D) -> Result<u32, D::Error> where     D: Deserializer,

impl Deserialize for u64

fn deserialize<D>(deserializer: &mut D) -> Result<u64, D::Error> where     D: Deserializer,

impl Deserialize for f32

fn deserialize<D>(deserializer: &mut D) -> Result<f32, D::Error> where     D: Deserializer,

impl Deserialize for f64

fn deserialize<D>(deserializer: &mut D) -> Result<f64, D::Error> where     D: Deserializer,

impl Deserialize for char

fn deserialize<D>(deserializer: &mut D) -> Result<char, D::Error> where     D: Deserializer,

impl Deserialize for String

fn deserialize<D>(deserializer: &mut D) -> Result<String, D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<Option<T>, D::Error> where     D: Deserializer,

impl<T> Deserialize for PhantomData<T>

fn deserialize<D>(deserializer: &mut D) -> Result<PhantomData<T>, D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<BinaryHeap<T>, D::Error> where     D: Deserializer,

impl<T> Deserialize for BTreeSet<T> where     T: Deserialize + Eq + Ord,

fn deserialize<D>(deserializer: &mut D) -> Result<BTreeSet<T>, D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<LinkedList<T>, D::Error> where     D: Deserializer,

impl<T, S> Deserialize for HashSet<T, S> where     T: Deserialize + Eq + Hash,     S: BuildHasher + Default,

fn deserialize<D>(deserializer: &mut D) -> Result<HashSet<T, S>, D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<Vec<T>, D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<VecDeque<T>, D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 0], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 1], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 2], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 3], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 4], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 5], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 6], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 7], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 8], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 9], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 10], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 11], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 12], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 13], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 14], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 15], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 16], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 17], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 18], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 19], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 20], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 21], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 22], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 23], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 24], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 25], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 26], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 27], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 28], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 29], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 30], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 31], D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<[T; 32], D::Error> where     D: Deserializer,

impl<T0: Deserialize> Deserialize for (T0,)

fn deserialize<D>(deserializer: &mut D) -> Result<(T0,), D::Error> where     D: Deserializer,

impl<T0: Deserialize, T1: Deserialize> Deserialize for (T0, T1)

fn deserialize<D>(deserializer: &mut D) -> Result<(T0, T1), D::Error> where     D: Deserializer,

impl<T0: Deserialize, T1: Deserialize, T2: Deserialize> Deserialize for (T0, T1, T2)

fn deserialize<D>(deserializer: &mut D) -> Result<(T0, T1, T2), D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<(T0, T1, T2, T3), D::Error> where     D: Deserializer,

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

fn deserialize<D>(     deserializer: &mut D ) -> Result<(T0, T1, T2, T3, T4), D::Error> where     D: Deserializer,

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

fn deserialize<D>(     deserializer: &mut D ) -> Result<(T0, T1, T2, T3, T4, T5), D::Error> where     D: Deserializer,

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

fn deserialize<D>(     deserializer: &mut D ) -> Result<(T0, T1, T2, T3, T4, T5, T6), D::Error> where     D: Deserializer,

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

fn deserialize<D>(     deserializer: &mut D ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7), D::Error> where     D: Deserializer,

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

fn deserialize<D>(     deserializer: &mut D ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8), D::Error> where     D: Deserializer,

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

fn deserialize<D>(     deserializer: &mut D ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9), D::Error> where     D: Deserializer,

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

fn deserialize<D>(     deserializer: &mut D ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10), D::Error> where     D: Deserializer,

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

fn deserialize<D>(     deserializer: &mut D ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11), D::Error> where     D: Deserializer,

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

fn deserialize<D>(     deserializer: &mut D ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12), D::Error> where     D: Deserializer,

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

fn deserialize<D>(     deserializer: &mut D ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13), D::Error> where     D: Deserializer,

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

fn deserialize<D>(     deserializer: &mut D ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14), D::Error> where     D: Deserializer,

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

fn deserialize<D>(     deserializer: &mut D ) -> Result<(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15), D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<BTreeMap<K, V>, D::Error> where     D: Deserializer,

impl<K, V, S> Deserialize for HashMap<K, V, S> where     K: Deserialize + Eq + Hash,     V: Deserialize,     S: BuildHasher + Default,

fn deserialize<D>(deserializer: &mut D) -> Result<HashMap<K, V, S>, D::Error> where     D: Deserializer,

impl Deserialize for IpAddr

fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error> where     D: Deserializer,

impl Deserialize for Ipv4Addr

fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error> where     D: Deserializer,

impl Deserialize for Ipv6Addr

fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error> where     D: Deserializer,

impl Deserialize for SocketAddr

fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error> where     D: Deserializer,

impl Deserialize for SocketAddrV4

fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error> where     D: Deserializer,

impl Deserialize for SocketAddrV6

fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error> where     D: Deserializer,

impl Deserialize for PathBuf

fn deserialize<D>(deserializer: &mut D) -> Result<PathBuf, D::Error> where     D: Deserializer,

impl<T: Deserialize> Deserialize for Box<T>

fn deserialize<D>(deserializer: &mut D) -> Result<Box<T>, D::Error> where     D: Deserializer,

impl<T: Deserialize> Deserialize for Box<[T]>

fn deserialize<D>(deserializer: &mut D) -> Result<Box<[T]>, D::Error> where     D: Deserializer,

impl Deserialize for Box<str>

fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error> where     D: Deserializer,

impl<T: Deserialize> Deserialize for Arc<T>

fn deserialize<D>(deserializer: &mut D) -> Result<Arc<T>, D::Error> where     D: Deserializer,

impl<T: Deserialize> Deserialize for Rc<T>

fn deserialize<D>(deserializer: &mut D) -> Result<Rc<T>, D::Error> where     D: Deserializer,

impl<'a, T: ?Sized> Deserialize for Cow<'a, T> where     T: ToOwned,     T::Owned: Deserialize,

fn deserialize<D>(deserializer: &mut D) -> Result<Cow<'a, T>, D::Error> where     D: Deserializer,

impl Deserialize for Duration

fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error> where     D: Deserializer,

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

fn deserialize<D>(deserializer: &mut D) -> Result<Result<T, E>, D::Error> where     D: Deserializer,

Implementors

impl Deserialize for ByteBuf

fn deserialize<D>(deserializer: &mut D) -> Result<ByteBuf, D::Error> where     D: Deserializer,

impl Deserialize for IgnoredAny

fn deserialize<D>(deserializer: &mut D) -> Result<IgnoredAny, D::Error> where     D: Deserializer,