Trait Deserialize 

pub trait Deserialize<T, D: Fallible + ?Sized> {
    // Required method
    fn deserialize(&self, deserializer: &mut D) -> Result<T, D::Error>;
}

Converts a type back from its archived form.

Some types may require specific deserializer capabilities, such as Rc and Arc. In these cases, the deserializer type D should be bound so that it implements traits that provide those capabilities (e.g. SharedDeserializeRegistry).

This can be derived with Deserialize.

Required Methods

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

Deserializes using the given deserializer

Implementations on Foreign Types

impl<D: Fallible + ?Sized> Deserialize<char, D> for char

fn deserialize(&self, _: &mut D) -> Result<char, D::Error>

impl<D: Fallible + ?Sized> Deserialize<f32, D> for f32

fn deserialize(&self, _: &mut D) -> Result<f32, D::Error>

impl<D: Fallible + ?Sized> Deserialize<f64, D> for f64

fn deserialize(&self, _: &mut D) -> Result<f64, D::Error>

impl<D: Fallible + ?Sized> Deserialize<i16, D> for i16

fn deserialize(&self, _: &mut D) -> Result<i16, D::Error>

impl<D: Fallible + ?Sized> Deserialize<i32, D> for i32

fn deserialize(&self, _: &mut D) -> Result<i32, D::Error>

impl<D: Fallible + ?Sized> Deserialize<i64, D> for i64

fn deserialize(&self, _: &mut D) -> Result<i64, D::Error>

impl<D: Fallible + ?Sized> Deserialize<i128, D> for i128

fn deserialize(&self, _: &mut D) -> Result<i128, D::Error>

impl<D: Fallible + ?Sized> Deserialize<u16, D> for u16

fn deserialize(&self, _: &mut D) -> Result<u16, D::Error>

impl<D: Fallible + ?Sized> Deserialize<u32, D> for u32

fn deserialize(&self, _: &mut D) -> Result<u32, D::Error>

impl<D: Fallible + ?Sized> Deserialize<u64, D> for u64

fn deserialize(&self, _: &mut D) -> Result<u64, D::Error>

impl<D: Fallible + ?Sized> Deserialize<u128, D> for u128

fn deserialize(&self, _: &mut D) -> Result<u128, D::Error>

impl<D: Fallible + ?Sized> Deserialize<BigEndian<AtomicI16>, D> for i16_be

fn deserialize(&self, _: &mut D) -> Result<AtomicI16_be, D::Error>

impl<D: Fallible + ?Sized> Deserialize<BigEndian<AtomicI32>, D> for i32_be

fn deserialize(&self, _: &mut D) -> Result<AtomicI32_be, D::Error>

impl<D: Fallible + ?Sized> Deserialize<BigEndian<AtomicI64>, D> for i64_be

fn deserialize(&self, _: &mut D) -> Result<AtomicI64_be, D::Error>

impl<D: Fallible + ?Sized> Deserialize<BigEndian<AtomicU16>, D> for u16_be

fn deserialize(&self, _: &mut D) -> Result<AtomicU16_be, D::Error>

impl<D: Fallible + ?Sized> Deserialize<BigEndian<AtomicU32>, D> for u32_be

fn deserialize(&self, _: &mut D) -> Result<AtomicU32_be, D::Error>

impl<D: Fallible + ?Sized> Deserialize<BigEndian<AtomicU64>, D> for u64_be

fn deserialize(&self, _: &mut D) -> Result<AtomicU64_be, D::Error>

impl<D: Fallible + ?Sized> Deserialize<LittleEndian<AtomicI16>, D> for i16_le

fn deserialize(&self, _: &mut D) -> Result<AtomicI16_le, D::Error>

impl<D: Fallible + ?Sized> Deserialize<LittleEndian<AtomicI32>, D> for i32_le

fn deserialize(&self, _: &mut D) -> Result<AtomicI32_le, D::Error>

impl<D: Fallible + ?Sized> Deserialize<LittleEndian<AtomicI64>, D> for i64_le

fn deserialize(&self, _: &mut D) -> Result<AtomicI64_le, D::Error>

impl<D: Fallible + ?Sized> Deserialize<LittleEndian<AtomicU16>, D> for u16_le

fn deserialize(&self, _: &mut D) -> Result<AtomicU16_le, D::Error>

impl<D: Fallible + ?Sized> Deserialize<LittleEndian<AtomicU32>, D> for u32_le

fn deserialize(&self, _: &mut D) -> Result<AtomicU32_le, D::Error>

impl<D: Fallible + ?Sized> Deserialize<LittleEndian<AtomicU64>, D> for u64_le

fn deserialize(&self, _: &mut D) -> Result<AtomicU64_le, D::Error>

impl<D: Fallible + ?Sized> Deserialize<PhantomPinned, D> for PhantomPinned

fn deserialize(&self, _: &mut D) -> Result<PhantomPinned, D::Error>

impl<D: Fallible + ?Sized> Deserialize<NonZero<i16>, D> for NonZeroI16

fn deserialize(&self, _: &mut D) -> Result<NonZeroI16, D::Error>

impl<D: Fallible + ?Sized> Deserialize<NonZero<i32>, D> for NonZeroI32

fn deserialize(&self, _: &mut D) -> Result<NonZeroI32, D::Error>

impl<D: Fallible + ?Sized> Deserialize<NonZero<i64>, D> for NonZeroI64

fn deserialize(&self, _: &mut D) -> Result<NonZeroI64, D::Error>

impl<D: Fallible + ?Sized> Deserialize<NonZero<i128>, D> for NonZeroI128

fn deserialize(&self, _: &mut D) -> Result<NonZeroI128, D::Error>

impl<D: Fallible + ?Sized> Deserialize<NonZero<u16>, D> for NonZeroU16

fn deserialize(&self, _: &mut D) -> Result<NonZeroU16, D::Error>

impl<D: Fallible + ?Sized> Deserialize<NonZero<u32>, D> for NonZeroU32

fn deserialize(&self, _: &mut D) -> Result<NonZeroU32, D::Error>

impl<D: Fallible + ?Sized> Deserialize<NonZero<u64>, D> for NonZeroU64

fn deserialize(&self, _: &mut D) -> Result<NonZeroU64, D::Error>

impl<D: Fallible + ?Sized> Deserialize<NonZero<u128>, D> for NonZeroU128

fn deserialize(&self, _: &mut D) -> Result<NonZeroU128, D::Error>

impl<D: Fallible + ?Sized> Deserialize<RangeFull, D> for RangeFull

fn deserialize(&self, _: &mut D) -> Result<Self, D::Error>

impl<T: Archive, D: Fallible + ?Sized> Deserialize<ManuallyDrop<T>, D> for ManuallyDrop<T::Archived>

where T::Archived: Deserialize<T, D>,

fn deserialize( &self, deserializer: &mut D, ) -> Result<ManuallyDrop<T>, <D as Fallible>::Error>

impl<T: Archive, D: Fallible + ?Sized, const N: usize> Deserialize<[T; N], D> for [T::Archived; N]

where T::Archived: Deserialize<T, D>,

fn deserialize(&self, deserializer: &mut D) -> Result<[T; N], D::Error>

impl<T: ?Sized, D: Fallible + ?Sized> Deserialize<PhantomData<T>, D> for PhantomData<T>

fn deserialize(&self, _: &mut D) -> Result<PhantomData<T>, D::Error>

Implementors

impl<D: Fallible + ?Sized> Deserialize<IpAddr, D> for ArchivedIpAddr

impl<D: Fallible + ?Sized> Deserialize<SocketAddr, D> for ArchivedSocketAddr

impl<D: Fallible + ?Sized> Deserialize<bool, D> for Archived<bool>

impl<D: Fallible + ?Sized> Deserialize<i8, D> for Archived<i8>

impl<D: Fallible + ?Sized> Deserialize<isize, D> for Archived<isize>

impl<D: Fallible + ?Sized> Deserialize<u8, D> for Archived<u8>

impl<D: Fallible + ?Sized> Deserialize<(), D> for Archived<()>

impl<D: Fallible + ?Sized> Deserialize<usize, D> for Archived<usize>

impl<D: Fallible + ?Sized> Deserialize<BigEndian<char>, D> for Archived<char_be>

impl<D: Fallible + ?Sized> Deserialize<BigEndian<f32>, D> for Archived<f32_be>

impl<D: Fallible + ?Sized> Deserialize<BigEndian<f64>, D> for Archived<f64_be>

impl<D: Fallible + ?Sized> Deserialize<BigEndian<i16>, D> for Archived<i16_be>

impl<D: Fallible + ?Sized> Deserialize<BigEndian<i32>, D> for Archived<i32_be>

impl<D: Fallible + ?Sized> Deserialize<BigEndian<i64>, D> for Archived<i64_be>

impl<D: Fallible + ?Sized> Deserialize<BigEndian<i128>, D> for Archived<i128_be>

impl<D: Fallible + ?Sized> Deserialize<BigEndian<u16>, D> for Archived<u16_be>

impl<D: Fallible + ?Sized> Deserialize<BigEndian<u32>, D> for Archived<u32_be>

impl<D: Fallible + ?Sized> Deserialize<BigEndian<u64>, D> for Archived<u64_be>

impl<D: Fallible + ?Sized> Deserialize<BigEndian<u128>, D> for Archived<u128_be>

impl<D: Fallible + ?Sized> Deserialize<BigEndian<NonZero<i16>>, D> for Archived<NonZeroI16_be>

impl<D: Fallible + ?Sized> Deserialize<BigEndian<NonZero<i32>>, D> for Archived<NonZeroI32_be>

impl<D: Fallible + ?Sized> Deserialize<BigEndian<NonZero<i64>>, D> for Archived<NonZeroI64_be>

impl<D: Fallible + ?Sized> Deserialize<BigEndian<NonZero<i128>>, D> for Archived<NonZeroI128_be>

impl<D: Fallible + ?Sized> Deserialize<BigEndian<NonZero<u16>>, D> for Archived<NonZeroU16_be>

impl<D: Fallible + ?Sized> Deserialize<BigEndian<NonZero<u32>>, D> for Archived<NonZeroU32_be>

impl<D: Fallible + ?Sized> Deserialize<BigEndian<NonZero<u64>>, D> for Archived<NonZeroU64_be>

impl<D: Fallible + ?Sized> Deserialize<BigEndian<NonZero<u128>>, D> for Archived<NonZeroU128_be>

impl<D: Fallible + ?Sized> Deserialize<LittleEndian<char>, D> for Archived<char_le>

impl<D: Fallible + ?Sized> Deserialize<LittleEndian<f32>, D> for Archived<f32_le>

impl<D: Fallible + ?Sized> Deserialize<LittleEndian<f64>, D> for Archived<f64_le>

impl<D: Fallible + ?Sized> Deserialize<LittleEndian<i16>, D> for Archived<i16_le>

impl<D: Fallible + ?Sized> Deserialize<LittleEndian<i32>, D> for Archived<i32_le>

impl<D: Fallible + ?Sized> Deserialize<LittleEndian<i64>, D> for Archived<i64_le>

impl<D: Fallible + ?Sized> Deserialize<LittleEndian<i128>, D> for Archived<i128_le>

impl<D: Fallible + ?Sized> Deserialize<LittleEndian<u16>, D> for Archived<u16_le>

impl<D: Fallible + ?Sized> Deserialize<LittleEndian<u32>, D> for Archived<u32_le>

impl<D: Fallible + ?Sized> Deserialize<LittleEndian<u64>, D> for Archived<u64_le>

impl<D: Fallible + ?Sized> Deserialize<LittleEndian<u128>, D> for Archived<u128_le>

impl<D: Fallible + ?Sized> Deserialize<LittleEndian<NonZero<i16>>, D> for Archived<NonZeroI16_le>

impl<D: Fallible + ?Sized> Deserialize<LittleEndian<NonZero<i32>>, D> for Archived<NonZeroI32_le>

impl<D: Fallible + ?Sized> Deserialize<LittleEndian<NonZero<i64>>, D> for Archived<NonZeroI64_le>

impl<D: Fallible + ?Sized> Deserialize<LittleEndian<NonZero<i128>>, D> for Archived<NonZeroI128_le>

impl<D: Fallible + ?Sized> Deserialize<LittleEndian<NonZero<u16>>, D> for Archived<NonZeroU16_le>

impl<D: Fallible + ?Sized> Deserialize<LittleEndian<NonZero<u32>>, D> for Archived<NonZeroU32_le>

impl<D: Fallible + ?Sized> Deserialize<LittleEndian<NonZero<u64>>, D> for Archived<NonZeroU64_le>

impl<D: Fallible + ?Sized> Deserialize<LittleEndian<NonZero<u128>>, D> for Archived<NonZeroU128_le>

impl<D: Fallible + ?Sized> Deserialize<CString, D> for Archived<CString>

where CStr: DeserializeUnsized<CStr, D>,

impl<D: Fallible + ?Sized> Deserialize<String, D> for ArchivedString

where str: DeserializeUnsized<str, D>,

impl<D: Fallible + ?Sized> Deserialize<Ipv4Addr, D> for ArchivedIpv4Addr

impl<D: Fallible + ?Sized> Deserialize<Ipv6Addr, D> for ArchivedIpv6Addr

impl<D: Fallible + ?Sized> Deserialize<SocketAddrV4, D> for ArchivedSocketAddrV4

impl<D: Fallible + ?Sized> Deserialize<SocketAddrV6, D> for ArchivedSocketAddrV6

impl<D: Fallible + ?Sized> Deserialize<NonZero<i8>, D> for Archived<NonZeroI8>

impl<D: Fallible + ?Sized> Deserialize<NonZero<isize>, D> for Archived<NonZeroIsize>

impl<D: Fallible + ?Sized> Deserialize<NonZero<u8>, D> for Archived<NonZeroU8>

impl<D: Fallible + ?Sized> Deserialize<NonZero<usize>, D> for Archived<NonZeroUsize>

impl<D: Fallible + ?Sized> Deserialize<AtomicBool, D> for Archived<AtomicBool>

impl<D: Fallible + ?Sized> Deserialize<AtomicI8, D> for Archived<AtomicI8>

impl<D: Fallible + ?Sized> Deserialize<AtomicI16, D> for Archived<AtomicI16>

impl<D: Fallible + ?Sized> Deserialize<AtomicI32, D> for Archived<AtomicI32>

impl<D: Fallible + ?Sized> Deserialize<AtomicI64, D> for Archived<AtomicI64>

impl<D: Fallible + ?Sized> Deserialize<AtomicIsize, D> for Archived<AtomicIsize>

Available on has_atomics only.

impl<D: Fallible + ?Sized> Deserialize<AtomicU8, D> for Archived<AtomicU8>

impl<D: Fallible + ?Sized> Deserialize<AtomicU16, D> for Archived<AtomicU16>

impl<D: Fallible + ?Sized> Deserialize<AtomicU32, D> for Archived<AtomicU32>

impl<D: Fallible + ?Sized> Deserialize<AtomicU64, D> for Archived<AtomicU64>

impl<D: Fallible + ?Sized> Deserialize<AtomicUsize, D> for Archived<AtomicUsize>

Available on has_atomics only.

impl<D: Fallible + ?Sized> Deserialize<Duration, D> for ArchivedDuration

impl<F, W, T, D> Deserialize<With<T, W>, D> for F

where F: ?Sized, W: DeserializeWith<F, T, D>, D: Fallible + ?Sized,

impl<K, D> Deserialize<BTreeSet<K>, D> for ArchivedBTreeSet<K::Archived>

where K: Archive + Ord, K::Archived: Deserialize<K, D> + Ord, D: Fallible + ?Sized,

impl<K, D, S> Deserialize<HashSet<K, S>, D> for ArchivedHashSet<K::Archived>

where K: Archive + Hash + Eq, K::Archived: Deserialize<K, D> + Hash + Eq, D: Fallible + ?Sized, S: Default + BuildHasher,

impl<K, D, S> Deserialize<IndexSet<K, S>, D> for ArchivedIndexSet<K::Archived>

where K: Archive + Hash + Eq, K::Archived: Deserialize<K, D>, D: Fallible + ?Sized, S: Default + BuildHasher,

impl<K, D, S> Deserialize<HashSet<K, S>, D> for ArchivedHashSet<K::Archived>

where K: Archive + Hash + Eq, K::Archived: Deserialize<K, D> + Hash + Eq, D: Fallible + ?Sized, S: Default + BuildHasher,

impl<K, V, D, S> Deserialize<IndexMap<K, V, S>, D> for ArchivedIndexMap<K::Archived, V::Archived>

where K: Archive + Hash + Eq, K::Archived: Deserialize<K, D>, V: Archive, V::Archived: Deserialize<V, D>, D: Fallible + ?Sized, S: Default + BuildHasher,

impl<K: Archive + Ord, V: Archive, D: Fallible + ?Sized> Deserialize<BTreeMap<K, V>, D> for ArchivedBTreeMap<K::Archived, V::Archived>

where K::Archived: Deserialize<K, D> + Ord, V::Archived: Deserialize<V, D>,

impl<K: Archive + Hash + Eq, V: Archive, D: Fallible + ?Sized, S: Default + BuildHasher> Deserialize<HashMap<K, V, S>, D> for ArchivedHashMap<K::Archived, V::Archived>

where K::Archived: Deserialize<K, D> + Hash + Eq, V::Archived: Deserialize<V, D>,

impl<K: Archive + Hash + Eq, V: Archive, D: Fallible + ?Sized, S: Default + BuildHasher> Deserialize<HashMap<K, V, S>, D> for ArchivedHashMap<K::Archived, V::Archived>

where K::Archived: Deserialize<K, D> + Hash + Eq, V::Archived: Deserialize<V, D>,

impl<T, D> Deserialize<Box<T>, D> for ArchivedBox<T::Archived>

where T: ArchiveUnsized + ?Sized, T::Archived: DeserializeUnsized<T, D>, D: Fallible + ?Sized,

impl<T, D> Deserialize<Rc<T>, D> for ArchivedRc<T::Archived, RcFlavor>

where T: ArchiveUnsized + ?Sized + 'static, T::Archived: DeserializeUnsized<T, D>, D: SharedDeserializeRegistry + ?Sized,

impl<T, D> Deserialize<Weak<T>, D> for ArchivedRcWeak<T::Archived, RcFlavor>

where T: Archive + 'static, T::Archived: DeserializeUnsized<T, D>, D: SharedDeserializeRegistry + ?Sized,

impl<T, D> Deserialize<Weak<T>, D> for ArchivedRcWeak<T::Archived, ArcFlavor>

where T: Archive + 'static, T::Archived: DeserializeUnsized<T, D>, D: SharedDeserializeRegistry + ?Sized,

Available on has_atomics only.

impl<T, D> Deserialize<RangeInclusive<T>, D> for Archived<RangeInclusive<T>>

where T: Archive, T::Archived: Deserialize<T, D>, D: Fallible + ?Sized,

impl<T, D> Deserialize<RangeToInclusive<T>, D> for Archived<RangeToInclusive<T>>

where T: Archive, T::Archived: Deserialize<T, D>, D: Fallible + ?Sized,

impl<T, E, D> Deserialize<Result<T, E>, D> for ArchivedResult<T::Archived, E::Archived>

where T: Archive, E: Archive, D: Fallible + ?Sized, T::Archived: Deserialize<T, D>, E::Archived: Deserialize<E, D>,

impl<T: Archive, D: Fallible + ?Sized> Deserialize<Option<T>, D> for ArchivedOption<T::Archived>

where T::Archived: Deserialize<T, D>,

impl<T: Archive, D: Fallible + ?Sized> Deserialize<VecDeque<T>, D> for ArchivedVec<T::Archived>

where [T::Archived]: DeserializeUnsized<[T], D>,

impl<T: Archive, D: Fallible + ?Sized> Deserialize<Vec<T>, D> for ArchivedVec<T::Archived>

where [T::Archived]: DeserializeUnsized<[T], D>,

impl<T: Archive, D: Fallible + ?Sized> Deserialize<Range<T>, D> for Archived<Range<T>>

where T::Archived: Deserialize<T, D>,

impl<T: Archive, D: Fallible + ?Sized> Deserialize<RangeFrom<T>, D> for Archived<RangeFrom<T>>

where T::Archived: Deserialize<T, D>,

impl<T: Archive, D: Fallible + ?Sized> Deserialize<RangeTo<T>, D> for Archived<RangeTo<T>>

where T::Archived: Deserialize<T, D>,

impl<T: ArchiveUnsized + ?Sized + 'static, D: SharedDeserializeRegistry + ?Sized> Deserialize<Arc<T>, D> for ArchivedRc<T::Archived, ArcFlavor>

where T::Archived: DeserializeUnsized<T, D>,

Available on has_atomics only.

impl<__D: Fallible + ?Sized, const N: usize> Deserialize<AlignedBytes<N>, __D> for Archived<AlignedBytes<N>>

where [u8; N]: Archive, Archived<[u8; N]>: Deserialize<[u8; N], __D>,