Trait rkyv::Deserialize

pub trait Deserialize<T: Archive<Archived = Self>, D: Fallible + ?Sized> {
    fn deserialize(&self, deserializer: &mut D) -> Result<T, D::Error>;
}

Converts a type back from its archived form.

This can be derived with Deserialize.

Required methods

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

Deserializes using the given deserializer

Loading content...

Implementations on Foreign Types

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Loading content...

Implementors

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

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

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

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

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

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

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

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

impl<K: Archive + Hash + Eq, D: Fallible + ?Sized> Deserialize<HashSet<K, RandomState>, D> for Archived<HashSet<K>> where
    K::Archived: Deserialize<K, D> + Hash + Eq, 

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

impl<K: Archive + Hash + Eq, V: Archive, D: Fallible + ?Sized> Deserialize<HashMap<K, V, RandomState>, D> for Archived<HashMap<K, V>> where
    K::Archived: Deserialize<K, D> + Hash + Eq,
    V::Archived: Deserialize<V, D>, 

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

impl<T: Archive + 'static, D: SharedDeserializer + ?Sized> Deserialize<Weak<T>, D> for Archived<Weak<T>> where
    T::Archived: DeserializeUnsized<T, D>, 

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

impl<T: Archive + 'static, D: SharedDeserializer + ?Sized> Deserialize<Weak<T>, D> for Archived<Weak<T>> where
    T::Archived: DeserializeUnsized<T, D>, 

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

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

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

impl<T: Archive, D: Fallible + ?Sized> Deserialize<Vec<T, Global>, D> for Archived<Vec<T>> where
    [T::Archived]: DeserializeUnsized<[T], D>, 

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

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

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

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

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

impl<T: ArchiveUnsized + ?Sized + 'static, D: SharedDeserializer + ?Sized> Deserialize<Rc<T>, D> for Archived<Rc<T>> where
    T::Archived: DeserializeUnsized<T, D>, 

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

impl<T: ArchiveUnsized + ?Sized + 'static, D: SharedDeserializer + ?Sized> Deserialize<Arc<T>, D> for Archived<Arc<T>> where
    T::Archived: DeserializeUnsized<T, D>, 

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

impl<T: ArchiveUnsized + ?Sized, D: Deserializer + ?Sized> Deserialize<Box<T, Global>, D> for Archived<Box<T>> where
    T::Archived: DeserializeUnsized<T, D>, 

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

Loading content...