Type Definition rkyv::Archived

pub type Archived<T> = <T as Archive>::Archived;

Alias for the archived version of some Archive type.

This can be useful for reducing the lengths of type definitions.

Trait Implementations

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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>

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

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

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

Deserializes using the given deserializer

impl Offset for Archived<i16>

fn between(from: usize, to: usize) -> Result<Self, OffsetError>

Creates a new offset between a from position and a to position.

fn to_isize(&self) -> isize

Gets the offset as an isize.

impl Offset for Archived<i32>

fn between(from: usize, to: usize) -> Result<Self, OffsetError>

Creates a new offset between a from position and a to position.

fn to_isize(&self) -> isize

Gets the offset as an isize.

impl Offset for Archived<i64>

fn between(from: usize, to: usize) -> Result<Self, OffsetError>

Creates a new offset between a from position and a to position.

fn to_isize(&self) -> isize

Gets the offset as an isize.

impl Offset for Archived<u16>

fn between(from: usize, to: usize) -> Result<Self, OffsetError>

Creates a new offset between a from position and a to position.

fn to_isize(&self) -> isize

Gets the offset as an isize.

impl Offset for Archived<u32>

fn between(from: usize, to: usize) -> Result<Self, OffsetError>

Creates a new offset between a from position and a to position.

fn to_isize(&self) -> isize

Gets the offset as an isize.

impl Offset for Archived<u64>

fn between(from: usize, to: usize) -> Result<Self, OffsetError>

Creates a new offset between a from position and a to position.

fn to_isize(&self) -> isize

Gets the offset as an isize.