Trait rkyv::Deserialize

pub trait Deserialize<T, D: Fallible + ?Sized> {
    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<RangeFull, D> for RangeFull

fn deserialize(&self, _: &mut D) -> Result<Self, 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<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<char, D> for char

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn deserialize(&self, _: &mut D) -> Result<NonZeroU128, 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>

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

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

impl<D: Fallible + ?Sized, T11: Archive, T10: Archive, T9: Archive, T8: Archive, T7: Archive, T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Deserialize<(T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0), D> for (T11::Archived, T10::Archived, T9::Archived, T8::Archived, T7::Archived, T6::Archived, T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived) where
    T11::Archived: Deserialize<T11, D>,
    T10::Archived: Deserialize<T10, D>,
    T9::Archived: Deserialize<T9, D>,
    T8::Archived: Deserialize<T8, D>,
    T7::Archived: Deserialize<T7, D>,
    T6::Archived: Deserialize<T6, D>,
    T5::Archived: Deserialize<T5, D>,
    T4::Archived: Deserialize<T4, D>,
    T3::Archived: Deserialize<T3, D>,
    T2::Archived: Deserialize<T2, D>,
    T1::Archived: Deserialize<T1, D>,
    T0::Archived: Deserialize<T0, D>, 

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

impl<D: Fallible + ?Sized, T10: Archive, T9: Archive, T8: Archive, T7: Archive, T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Deserialize<(T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0), D> for (T10::Archived, T9::Archived, T8::Archived, T7::Archived, T6::Archived, T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived) where
    T10::Archived: Deserialize<T10, D>,
    T9::Archived: Deserialize<T9, D>,
    T8::Archived: Deserialize<T8, D>,
    T7::Archived: Deserialize<T7, D>,
    T6::Archived: Deserialize<T6, D>,
    T5::Archived: Deserialize<T5, D>,
    T4::Archived: Deserialize<T4, D>,
    T3::Archived: Deserialize<T3, D>,
    T2::Archived: Deserialize<T2, D>,
    T1::Archived: Deserialize<T1, D>,
    T0::Archived: Deserialize<T0, D>, 

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

impl<D: Fallible + ?Sized, T9: Archive, T8: Archive, T7: Archive, T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Deserialize<(T9, T8, T7, T6, T5, T4, T3, T2, T1, T0), D> for (T9::Archived, T8::Archived, T7::Archived, T6::Archived, T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived) where
    T9::Archived: Deserialize<T9, D>,
    T8::Archived: Deserialize<T8, D>,
    T7::Archived: Deserialize<T7, D>,
    T6::Archived: Deserialize<T6, D>,
    T5::Archived: Deserialize<T5, D>,
    T4::Archived: Deserialize<T4, D>,
    T3::Archived: Deserialize<T3, D>,
    T2::Archived: Deserialize<T2, D>,
    T1::Archived: Deserialize<T1, D>,
    T0::Archived: Deserialize<T0, D>, 

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

impl<D: Fallible + ?Sized, T8: Archive, T7: Archive, T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Deserialize<(T8, T7, T6, T5, T4, T3, T2, T1, T0), D> for (T8::Archived, T7::Archived, T6::Archived, T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived) where
    T8::Archived: Deserialize<T8, D>,
    T7::Archived: Deserialize<T7, D>,
    T6::Archived: Deserialize<T6, D>,
    T5::Archived: Deserialize<T5, D>,
    T4::Archived: Deserialize<T4, D>,
    T3::Archived: Deserialize<T3, D>,
    T2::Archived: Deserialize<T2, D>,
    T1::Archived: Deserialize<T1, D>,
    T0::Archived: Deserialize<T0, D>, 

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

impl<D: Fallible + ?Sized, T7: Archive, T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Deserialize<(T7, T6, T5, T4, T3, T2, T1, T0), D> for (T7::Archived, T6::Archived, T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived) where
    T7::Archived: Deserialize<T7, D>,
    T6::Archived: Deserialize<T6, D>,
    T5::Archived: Deserialize<T5, D>,
    T4::Archived: Deserialize<T4, D>,
    T3::Archived: Deserialize<T3, D>,
    T2::Archived: Deserialize<T2, D>,
    T1::Archived: Deserialize<T1, D>,
    T0::Archived: Deserialize<T0, D>, 

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

impl<D: Fallible + ?Sized, T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Deserialize<(T6, T5, T4, T3, T2, T1, T0), D> for (T6::Archived, T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived) where
    T6::Archived: Deserialize<T6, D>,
    T5::Archived: Deserialize<T5, D>,
    T4::Archived: Deserialize<T4, D>,
    T3::Archived: Deserialize<T3, D>,
    T2::Archived: Deserialize<T2, D>,
    T1::Archived: Deserialize<T1, D>,
    T0::Archived: Deserialize<T0, D>, 

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

impl<D: Fallible + ?Sized, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Deserialize<(T5, T4, T3, T2, T1, T0), D> for (T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived) where
    T5::Archived: Deserialize<T5, D>,
    T4::Archived: Deserialize<T4, D>,
    T3::Archived: Deserialize<T3, D>,
    T2::Archived: Deserialize<T2, D>,
    T1::Archived: Deserialize<T1, D>,
    T0::Archived: Deserialize<T0, D>, 

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

impl<D: Fallible + ?Sized, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Deserialize<(T4, T3, T2, T1, T0), D> for (T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived) where
    T4::Archived: Deserialize<T4, D>,
    T3::Archived: Deserialize<T3, D>,
    T2::Archived: Deserialize<T2, D>,
    T1::Archived: Deserialize<T1, D>,
    T0::Archived: Deserialize<T0, D>, 

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

impl<D: Fallible + ?Sized, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Deserialize<(T3, T2, T1, T0), D> for (T3::Archived, T2::Archived, T1::Archived, T0::Archived) where
    T3::Archived: Deserialize<T3, D>,
    T2::Archived: Deserialize<T2, D>,
    T1::Archived: Deserialize<T1, D>,
    T0::Archived: Deserialize<T0, D>, 

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

impl<D: Fallible + ?Sized, T2: Archive, T1: Archive, T0: Archive> Deserialize<(T2, T1, T0), D> for (T2::Archived, T1::Archived, T0::Archived) where
    T2::Archived: Deserialize<T2, D>,
    T1::Archived: Deserialize<T1, D>,
    T0::Archived: Deserialize<T0, D>, 

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

impl<D: Fallible + ?Sized, T1: Archive, T0: Archive> Deserialize<(T1, T0), D> for (T1::Archived, T0::Archived) where
    T1::Archived: Deserialize<T1, D>,
    T0::Archived: Deserialize<T0, D>, 

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

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

fn deserialize(&self, deserializer: &mut D) -> Result<(T0,), D::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<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>

Implementors

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

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

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<NonZeroI16>, D> for Archived<NonZeroI16_be>

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

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

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

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

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

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

impl<D: Fallible + ?Sized> Deserialize<BigEndian<NonZeroU128>, 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<NonZeroI16>, D> for Archived<NonZeroI16_le>

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

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

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

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

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

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

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

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

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

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

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

impl<D: Fallible + ?Sized> Deserialize<NonZeroUsize, 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>

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>

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

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

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

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

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

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

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, Global>, 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<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: 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, Global>, 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, Global>, 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, 

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<Vec<T, Global>, 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>,