Trait rkyv::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<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<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, 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<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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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<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<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>

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

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

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