[−][src]Trait rkyv::Archive

pub trait Archive {
    type Archived;
    type Resolver: Resolve<Self, Archived = Self::Archived>;
    fn archive<W: Write + ?Sized>(
        &self, 
        writer: &mut W
    ) -> Result<Self::Resolver, W::Error>;
}

Associated Types

`type Archived`

`type Resolver: Resolve<Self, Archived = Self::Archived>`

Loading content...

Required methods

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`

Loading content...

Implementations on Foreign Types

`impl Archive for () where (): Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for bool where bool: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for i8 where i8: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for i16 where i16: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for i32 where i32: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for i64 where i64: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for i128 where i128: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for u8 where u8: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for u16 where u16: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for u32 where u32: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for u64 where u64: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for u128 where u128: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for f32 where f32: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for f64 where f64: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for char where char: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T11: Archive, T10: Archive, T9: Archive, T8: Archive, T7: Archive, T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Archive for (T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)`[src]

`type Archived = (T11::Archived, T10::Archived, T9::Archived, T8::Archived, T7::Archived, T6::Archived, T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived)`

`type Resolver = (T11::Resolver, T10::Resolver, T9::Resolver, T8::Resolver, T7::Resolver, T6::Resolver, T5::Resolver, T4::Resolver, T3::Resolver, T2::Resolver, T1::Resolver, T0::Resolver)`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T10: Archive, T9: Archive, T8: Archive, T7: Archive, T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Archive for (T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)`[src]

`type Archived = (T10::Archived, T9::Archived, T8::Archived, T7::Archived, T6::Archived, T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived)`

`type Resolver = (T10::Resolver, T9::Resolver, T8::Resolver, T7::Resolver, T6::Resolver, T5::Resolver, T4::Resolver, T3::Resolver, T2::Resolver, T1::Resolver, T0::Resolver)`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T9: Archive, T8: Archive, T7: Archive, T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Archive for (T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)`[src]

`type Archived = (T9::Archived, T8::Archived, T7::Archived, T6::Archived, T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived)`

`type Resolver = (T9::Resolver, T8::Resolver, T7::Resolver, T6::Resolver, T5::Resolver, T4::Resolver, T3::Resolver, T2::Resolver, T1::Resolver, T0::Resolver)`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T8: Archive, T7: Archive, T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Archive for (T8, T7, T6, T5, T4, T3, T2, T1, T0)`[src]

`type Archived = (T8::Archived, T7::Archived, T6::Archived, T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived)`

`type Resolver = (T8::Resolver, T7::Resolver, T6::Resolver, T5::Resolver, T4::Resolver, T3::Resolver, T2::Resolver, T1::Resolver, T0::Resolver)`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T7: Archive, T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Archive for (T7, T6, T5, T4, T3, T2, T1, T0)`[src]

`type Archived = (T7::Archived, T6::Archived, T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived)`

`type Resolver = (T7::Resolver, T6::Resolver, T5::Resolver, T4::Resolver, T3::Resolver, T2::Resolver, T1::Resolver, T0::Resolver)`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Archive for (T6, T5, T4, T3, T2, T1, T0)`[src]

`type Archived = (T6::Archived, T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived)`

`type Resolver = (T6::Resolver, T5::Resolver, T4::Resolver, T3::Resolver, T2::Resolver, T1::Resolver, T0::Resolver)`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Archive for (T5, T4, T3, T2, T1, T0)`[src]

`type Archived = (T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived)`

`type Resolver = (T5::Resolver, T4::Resolver, T3::Resolver, T2::Resolver, T1::Resolver, T0::Resolver)`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Archive for (T4, T3, T2, T1, T0)`[src]

`type Archived = (T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived)`

`type Resolver = (T4::Resolver, T3::Resolver, T2::Resolver, T1::Resolver, T0::Resolver)`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T3: Archive, T2: Archive, T1: Archive, T0: Archive> Archive for (T3, T2, T1, T0)`[src]

`type Archived = (T3::Archived, T2::Archived, T1::Archived, T0::Archived)`

`type Resolver = (T3::Resolver, T2::Resolver, T1::Resolver, T0::Resolver)`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T2: Archive, T1: Archive, T0: Archive> Archive for (T2, T1, T0)`[src]

`type Archived = (T2::Archived, T1::Archived, T0::Archived)`

`type Resolver = (T2::Resolver, T1::Resolver, T0::Resolver)`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T1: Archive, T0: Archive> Archive for (T1, T0)`[src]

`type Archived = (T1::Archived, T0::Archived)`

`type Resolver = (T1::Resolver, T0::Resolver)`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T0: Archive> Archive for (T0,)`[src]

`type Archived = (T0::Archived,)`

`type Resolver = (T0::Resolver,)`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 31]`[src]

`type Archived = [T::Archived; 31]`

`type Resolver = [T::Resolver; 31]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 30]`[src]

`type Archived = [T::Archived; 30]`

`type Resolver = [T::Resolver; 30]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 29]`[src]

`type Archived = [T::Archived; 29]`

`type Resolver = [T::Resolver; 29]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 28]`[src]

`type Archived = [T::Archived; 28]`

`type Resolver = [T::Resolver; 28]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 27]`[src]

`type Archived = [T::Archived; 27]`

`type Resolver = [T::Resolver; 27]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 26]`[src]

`type Archived = [T::Archived; 26]`

`type Resolver = [T::Resolver; 26]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 25]`[src]

`type Archived = [T::Archived; 25]`

`type Resolver = [T::Resolver; 25]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 24]`[src]

`type Archived = [T::Archived; 24]`

`type Resolver = [T::Resolver; 24]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 23]`[src]

`type Archived = [T::Archived; 23]`

`type Resolver = [T::Resolver; 23]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 22]`[src]

`type Archived = [T::Archived; 22]`

`type Resolver = [T::Resolver; 22]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 21]`[src]

`type Archived = [T::Archived; 21]`

`type Resolver = [T::Resolver; 21]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 20]`[src]

`type Archived = [T::Archived; 20]`

`type Resolver = [T::Resolver; 20]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 19]`[src]

`type Archived = [T::Archived; 19]`

`type Resolver = [T::Resolver; 19]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 18]`[src]

`type Archived = [T::Archived; 18]`

`type Resolver = [T::Resolver; 18]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 17]`[src]

`type Archived = [T::Archived; 17]`

`type Resolver = [T::Resolver; 17]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 16]`[src]

`type Archived = [T::Archived; 16]`

`type Resolver = [T::Resolver; 16]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 15]`[src]

`type Archived = [T::Archived; 15]`

`type Resolver = [T::Resolver; 15]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 14]`[src]

`type Archived = [T::Archived; 14]`

`type Resolver = [T::Resolver; 14]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 13]`[src]

`type Archived = [T::Archived; 13]`

`type Resolver = [T::Resolver; 13]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 12]`[src]

`type Archived = [T::Archived; 12]`

`type Resolver = [T::Resolver; 12]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 11]`[src]

`type Archived = [T::Archived; 11]`

`type Resolver = [T::Resolver; 11]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 10]`[src]

`type Archived = [T::Archived; 10]`

`type Resolver = [T::Resolver; 10]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 9]`[src]

`type Archived = [T::Archived; 9]`

`type Resolver = [T::Resolver; 9]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 8]`[src]

`type Archived = [T::Archived; 8]`

`type Resolver = [T::Resolver; 8]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 7]`[src]

`type Archived = [T::Archived; 7]`

`type Resolver = [T::Resolver; 7]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 6]`[src]

`type Archived = [T::Archived; 6]`

`type Resolver = [T::Resolver; 6]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 5]`[src]

`type Archived = [T::Archived; 5]`

`type Resolver = [T::Resolver; 5]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 4]`[src]

`type Archived = [T::Archived; 4]`

`type Resolver = [T::Resolver; 4]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 3]`[src]

`type Archived = [T::Archived; 3]`

`type Resolver = [T::Resolver; 3]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 2]`[src]

`type Archived = [T::Archived; 2]`

`type Resolver = [T::Resolver; 2]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 1]`[src]

`type Archived = [T::Archived; 1]`

`type Resolver = [T::Resolver; 1]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for [T; 0]`[src]

`type Archived = [T::Archived; 0]`

`type Resolver = [T::Resolver; 0]`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for Option<T>`[src]

`type Archived = ArchivedOption<T::Archived>`

`type Resolver = Option<T::Resolver>`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<K: Archive + Hash + Eq, V: Archive> Archive for HashMap<K, V> where K::Archived: Hash + Eq,` [src]

`type Archived = ArchivedHashMap<K::Archived, V::Archived>`

`type Resolver = ArchivedHashMapResolver`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<K: Archive + Hash + Eq> Archive for HashSet<K> where K::Archived: Hash + Eq,` [src]

`type Archived = ArchivedHashSet<K::Archived>`

`type Resolver = ArchivedHashSetResolver`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for String`[src]

`type Archived = ArchivedString`

`type Resolver = StringResolver`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: ArchiveRef + ?Sized> Archive for Box<T>`[src]

`type Archived = ArchivedBox<Reference<T>>`

`type Resolver = BoxResolver<ReferenceResolver<T>>`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T: Archive> Archive for Vec<T>`[src]

`type Archived = ArchivedVec<Reference<[T]>>`

`type Resolver = VecResolver<ReferenceResolver<[T]>>`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

Loading content...

Implementors

Loading content...

[−][src]Trait rkyv::Archive

Associated Types

type Archived

type Resolver: Resolve<Self, Archived = Self::Archived>

Required methods

fn archive<W: Write + ?Sized>( &self, writer: &mut W) -> Result<Self::Resolver, W::Error>

Implementations on Foreign Types

impl Archive for () where (): Copy, [src]

type Archived = Self

type Resolver = SelfResolver

fn archive<W: Write + ?Sized>( &self, _writer: &mut W) -> Result<Self::Resolver, W::Error>[src]

impl Archive for bool where bool: Copy, [src]

type Archived = Self

type Resolver = SelfResolver

fn archive<W: Write + ?Sized>( &self, _writer: &mut W) -> Result<Self::Resolver, W::Error>[src]

impl Archive for i8 where i8: Copy, [src]

type Archived = Self

type Resolver = SelfResolver

fn archive<W: Write + ?Sized>( &self, _writer: &mut W) -> Result<Self::Resolver, W::Error>[src]

impl Archive for i16 where i16: Copy, [src]

type Archived = Self

type Resolver = SelfResolver

fn archive<W: Write + ?Sized>( &self, _writer: &mut W) -> Result<Self::Resolver, W::Error>[src]

impl Archive for i32 where i32: Copy, [src]

type Archived = Self

type Resolver = SelfResolver

fn archive<W: Write + ?Sized>( &self, _writer: &mut W) -> Result<Self::Resolver, W::Error>[src]

impl Archive for i64 where i64: Copy, [src]

type Archived = Self

type Resolver = SelfResolver

fn archive<W: Write + ?Sized>( &self, _writer: &mut W) -> Result<Self::Resolver, W::Error>[src]

impl Archive for i128 where i128: Copy, [src]

type Archived = Self

type Resolver = SelfResolver

fn archive<W: Write + ?Sized>( &self, _writer: &mut W) -> Result<Self::Resolver, W::Error>[src]

impl Archive for u8 where u8: Copy, [src]

type Archived = Self

type Resolver = SelfResolver

fn archive<W: Write + ?Sized>( &self, _writer: &mut W) -> Result<Self::Resolver, W::Error>[src]

impl Archive for u16 where u16: Copy, [src]

type Archived = Self

type Resolver = SelfResolver

fn archive<W: Write + ?Sized>( &self, _writer: &mut W) -> Result<Self::Resolver, W::Error>[src]

impl Archive for u32 where u32: Copy, [src]

type Archived = Self

type Resolver = SelfResolver

fn archive<W: Write + ?Sized>( &self, _writer: &mut W) -> Result<Self::Resolver, W::Error>[src]

impl Archive for u64 where u64: Copy, [src]

type Archived = Self

type Resolver = SelfResolver

fn archive<W: Write + ?Sized>( &self, _writer: &mut W) -> Result<Self::Resolver, W::Error>[src]

impl Archive for u128 where u128: Copy, [src]

type Archived = Self

type Resolver = SelfResolver

fn archive<W: Write + ?Sized>( &self, _writer: &mut W) -> Result<Self::Resolver, W::Error>[src]

impl Archive for f32 where f32: Copy, [src]

type Archived = Self

type Resolver = SelfResolver

fn archive<W: Write + ?Sized>( &self, _writer: &mut W) -> Result<Self::Resolver, W::Error>[src]

impl Archive for f64 where f64: Copy, [src]

type Archived = Self

type Resolver = SelfResolver

fn archive<W: Write + ?Sized>( &self, _writer: &mut W) -> Result<Self::Resolver, W::Error>[src]

impl Archive for char where char: Copy, [src]

type Archived = Self

type Resolver = SelfResolver

fn archive<W: Write + ?Sized>( &self, _writer: &mut W) -> Result<Self::Resolver, W::Error>[src]

impl<T11: Archive, T10: Archive, T9: Archive, T8: Archive, T7: Archive, T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Archive for (T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)[src]

type Archived = (T11::Archived, T10::Archived, T9::Archived, T8::Archived, T7::Archived, T6::Archived, T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived)

type Resolver = (T11::Resolver, T10::Resolver, T9::Resolver, T8::Resolver, T7::Resolver, T6::Resolver, T5::Resolver, T4::Resolver, T3::Resolver, T2::Resolver, T1::Resolver, T0::Resolver)

fn archive<W: Write + ?Sized>( &self, writer: &mut W) -> Result<Self::Resolver, W::Error>[src]

impl<T10: Archive, T9: Archive, T8: Archive, T7: Archive, T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Archive for (T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)[src]

type Archived = (T10::Archived, T9::Archived, T8::Archived, T7::Archived, T6::Archived, T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived)

type Resolver = (T10::Resolver, T9::Resolver, T8::Resolver, T7::Resolver, T6::Resolver, T5::Resolver, T4::Resolver, T3::Resolver, T2::Resolver, T1::Resolver, T0::Resolver)

fn archive<W: Write + ?Sized>( &self, writer: &mut W) -> Result<Self::Resolver, W::Error>[src]

impl<T9: Archive, T8: Archive, T7: Archive, T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Archive for (T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)[src]

type Archived = (T9::Archived, T8::Archived, T7::Archived, T6::Archived, T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived)

type Resolver = (T9::Resolver, T8::Resolver, T7::Resolver, T6::Resolver, T5::Resolver, T4::Resolver, T3::Resolver, T2::Resolver, T1::Resolver, T0::Resolver)

fn archive<W: Write + ?Sized>( &self, writer: &mut W) -> Result<Self::Resolver, W::Error>[src]

impl<T8: Archive, T7: Archive, T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Archive for (T8, T7, T6, T5, T4, T3, T2, T1, T0)[src]

`type Archived`

`type Resolver: Resolve<Self, Archived = Self::Archived>`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`

`impl Archive for () where (): Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for bool where bool: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for i8 where i8: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for i16 where i16: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for i32 where i32: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for i64 where i64: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for i128 where i128: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for u8 where u8: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for u16 where u16: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for u32 where u32: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for u64 where u64: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for u128 where u128: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for f32 where f32: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for f64 where f64: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl Archive for char where char: Copy,` [src]

`type Archived = Self`

`type Resolver = SelfResolver`

`fn archive<W: Write + ?Sized>( &self, _writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T11: Archive, T10: Archive, T9: Archive, T8: Archive, T7: Archive, T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Archive for (T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)`[src]

`type Archived = (T11::Archived, T10::Archived, T9::Archived, T8::Archived, T7::Archived, T6::Archived, T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived)`

`type Resolver = (T11::Resolver, T10::Resolver, T9::Resolver, T8::Resolver, T7::Resolver, T6::Resolver, T5::Resolver, T4::Resolver, T3::Resolver, T2::Resolver, T1::Resolver, T0::Resolver)`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T10: Archive, T9: Archive, T8: Archive, T7: Archive, T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Archive for (T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)`[src]

`type Archived = (T10::Archived, T9::Archived, T8::Archived, T7::Archived, T6::Archived, T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived)`

`type Resolver = (T10::Resolver, T9::Resolver, T8::Resolver, T7::Resolver, T6::Resolver, T5::Resolver, T4::Resolver, T3::Resolver, T2::Resolver, T1::Resolver, T0::Resolver)`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T9: Archive, T8: Archive, T7: Archive, T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Archive for (T9, T8, T7, T6, T5, T4, T3, T2, T1, T0)`[src]

`type Archived = (T9::Archived, T8::Archived, T7::Archived, T6::Archived, T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived)`

`type Resolver = (T9::Resolver, T8::Resolver, T7::Resolver, T6::Resolver, T5::Resolver, T4::Resolver, T3::Resolver, T2::Resolver, T1::Resolver, T0::Resolver)`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T8: Archive, T7: Archive, T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Archive for (T8, T7, T6, T5, T4, T3, T2, T1, T0)`[src]

`type Archived = (T8::Archived, T7::Archived, T6::Archived, T5::Archived, T4::Archived, T3::Archived, T2::Archived, T1::Archived, T0::Archived)`

`type Resolver = (T8::Resolver, T7::Resolver, T6::Resolver, T5::Resolver, T4::Resolver, T3::Resolver, T2::Resolver, T1::Resolver, T0::Resolver)`

`fn archive<W: Write + ?Sized>( &self, writer: &mut W ) -> Result<Self::Resolver, W::Error>`[src]

`impl<T7: Archive, T6: Archive, T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Archive for (T7, T6, T5, T4, T3, T2, T1, T0)`[src]