Trait rkyv::Archive [−][src]
pub trait Archive { type Archived; type Resolver; fn resolve(
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
); }
Expand description
A type that can be used without deserializing.
Archiving is done depth-first, writing any data owned by a type before writing the data for the type itself. The type must be able to create the archived type from only its own data and its resolver.
Examples
Most of the time, #[derive(Archive)]
will create an acceptable implementation. You can use the
#[archive(...)]
attribute to control how the implementation is generated. See the
Archive
derive macro for more details.
use rkyv::{ archived_root, de::deserializers::AllocDeserializer, ser::{Serializer, serializers::AlignedSerializer}, AlignedVec, Archive, Archived, Deserialize, Serialize, }; #[derive(Archive, Serialize, Deserialize, Debug, PartialEq)] struct Test { int: u8, string: String, option: Option<Vec<i32>>, } let value = Test { int: 42, string: "hello world".to_string(), option: Some(vec![1, 2, 3, 4]), }; let mut serializer = AlignedSerializer::new(AlignedVec::new()); serializer.serialize_value(&value).expect("failed to archive test"); let buf = serializer.into_inner(); let archived = unsafe { archived_root::<Test>(buf.as_slice()) }; assert_eq!(archived.int, value.int); assert_eq!(archived.string, value.string); assert_eq!(archived.option, value.option); let deserialized = archived.deserialize(&mut AllocDeserializer).unwrap(); assert_eq!(value, deserialized);
Many of the core and standard library types already have Archive
implementations available,
but you may need to implement Archive
for your own types in some cases the derive macro cannot
handle.
In this example, we add our own wrapper that serializes a &'static str
as if it’s owned.
Normally you can lean on the archived version of String
to do most of the work, but this
example does everything to demonstrate how to implement Archive
for your own types.
use core::{mem::MaybeUninit, slice, str}; use rkyv::{ archived_root, offset_of, project_struct, ser::{Serializer, serializers::AlignedSerializer}, AlignedVec, Archive, Archived, ArchiveUnsized, MetadataResolver, RelPtr, Serialize, SerializeUnsized, }; struct OwnedStr { inner: &'static str, } struct ArchivedOwnedStr { // This will be a relative pointer to our string ptr: RelPtr<str>, } impl ArchivedOwnedStr { // This will help us get the bytes of our type as a str again. fn as_str(&self) -> &str { unsafe { // The as_ptr() function of RelPtr will get a pointer the str &*self.ptr.as_ptr() } } } struct OwnedStrResolver { // This will be the position that the bytes of our string are stored at. // We'll use this to resolve the relative pointer of our // ArchivedOwnedStr. pos: usize, // The archived metadata for our str may also need a resolver. metadata_resolver: MetadataResolver<str>, } // The Archive implementation defines the archived version of our type and // determines how to turn the resolver into the archived form. The Serialize // implementations determine how to make a resolver from the original value. impl Archive for OwnedStr { type Archived = ArchivedOwnedStr; // This is the resolver we can create our Archived verison from. type Resolver = OwnedStrResolver; // The resolve function consumes the resolver and produces the archived // value at the given position. fn resolve( &self, pos: usize, resolver: Self::Resolver, out: &mut MaybeUninit<Self::Archived> ) { // We have to be careful to add the offset of the ptr field, // otherwise we'll be using the position of the ArchivedOwnedStr // instead of the position of the relative pointer. unsafe { self.inner.resolve_unsized( pos + offset_of!(Self::Archived, ptr), resolver.pos, resolver.metadata_resolver, project_struct!(out: Self::Archived => ptr), ); } } } // We restrict our serializer types with Serializer because we need its // capabilities to archive our type. For other types, we might need more or // less restrictive bounds on the type of S. impl<S: Serializer + ?Sized> Serialize<S> for OwnedStr { fn serialize( &self, serializer: &mut S ) -> Result<Self::Resolver, S::Error> { // This is where we want to write the bytes of our string and return // a resolver that knows where those bytes were written. // We also need to serialize the metadata for our str. Ok(OwnedStrResolver { pos: self.inner.serialize_unsized(serializer)?, metadata_resolver: self.inner.serialize_metadata(serializer)? }) } } let mut serializer = AlignedSerializer::new(AlignedVec::new()); const STR_VAL: &'static str = "I'm in an OwnedStr!"; let value = OwnedStr { inner: STR_VAL }; // It works! serializer.serialize_value(&value).expect("failed to archive test"); let buf = serializer.into_inner(); let archived = unsafe { archived_root::<OwnedStr>(buf.as_ref()) }; // Let's make sure our data got written correctly assert_eq!(archived.as_str(), STR_VAL);
Associated Types
Required methods
fn resolve(
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]
fn resolve(
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]Creates the archived version of this value at the given position and writes it to the given output.
The output should be initialized field-by-field rather than by writing a whole struct. This is because performing a typed copy will set all of the padding bytes to uninitialized, but they must remain whatever value they currently have. This is so that uninitialized memory doesn’t get leaked to the final archive.
Implementations on Foreign Types
impl<T: Archive> Archive for RangeInclusive<T>
[src]
impl<T: Archive> Archive for RangeInclusive<T>
[src]impl Archive for Duration
[src]
impl Archive for Duration
[src]type Archived = ArchivedDuration
type Resolver = ()
fn resolve(
&self,
pos: usize,
_: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]
&self,
pos: usize,
_: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
impl<T: ?Sized> Archive for PhantomData<T>
[src]
impl<T: ?Sized> Archive for PhantomData<T>
[src]type Archived = PhantomData<T>
type Resolver = ()
fn resolve(
&self,
_: usize,
_: Self::Resolver,
_: &mut MaybeUninit<Self::Archived>
)
[src]
&self,
_: usize,
_: Self::Resolver,
_: &mut MaybeUninit<Self::Archived>
)
impl Archive for NonZeroI16 where
NonZeroI16: Copy,
[src]
impl Archive for NonZeroI16 where
NonZeroI16: Copy,
[src]impl Archive for NonZeroI32 where
NonZeroI32: Copy,
[src]
impl Archive for NonZeroI32 where
NonZeroI32: Copy,
[src]impl Archive for NonZeroI64 where
NonZeroI64: Copy,
[src]
impl Archive for NonZeroI64 where
NonZeroI64: Copy,
[src]impl Archive for NonZeroI128 where
NonZeroI128: Copy,
[src]
impl Archive for NonZeroI128 where
NonZeroI128: Copy,
[src]impl Archive for NonZeroU16 where
NonZeroU16: Copy,
[src]
impl Archive for NonZeroU16 where
NonZeroU16: Copy,
[src]impl Archive for NonZeroU32 where
NonZeroU32: Copy,
[src]
impl Archive for NonZeroU32 where
NonZeroU32: Copy,
[src]impl Archive for NonZeroU64 where
NonZeroU64: Copy,
[src]
impl Archive for NonZeroU64 where
NonZeroU64: Copy,
[src]impl Archive for NonZeroU128 where
NonZeroU128: Copy,
[src]
impl Archive for NonZeroU128 where
NonZeroU128: Copy,
[src]impl Archive for usize
[src]
impl Archive for usize
[src]type Archived = ArchivedUsize
type Resolver = ()
fn resolve(
&self,
_: usize,
_: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]
&self,
_: usize,
_: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
impl Archive for isize
[src]
impl Archive for isize
[src]type Archived = ArchivedIsize
type Resolver = ()
fn resolve(
&self,
_: usize,
_: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]
&self,
_: usize,
_: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
impl Archive for AtomicBool
[src]
impl Archive for AtomicBool
[src]type Archived = Self
type Resolver = AtomicResolver
fn resolve(
&self,
_pos: usize,
_resolver: AtomicResolver,
out: &mut MaybeUninit<AtomicBool>
)
[src]
&self,
_pos: usize,
_resolver: AtomicResolver,
out: &mut MaybeUninit<AtomicBool>
)
impl Archive for AtomicI8
[src]
impl Archive for AtomicI8
[src]type Archived = Self
type Resolver = AtomicResolver
fn resolve(
&self,
_pos: usize,
_resolver: AtomicResolver,
out: &mut MaybeUninit<AtomicI8>
)
[src]
&self,
_pos: usize,
_resolver: AtomicResolver,
out: &mut MaybeUninit<AtomicI8>
)
impl Archive for AtomicI16
[src]
impl Archive for AtomicI16
[src]type Archived = Self
type Resolver = AtomicResolver
fn resolve(
&self,
_pos: usize,
_resolver: AtomicResolver,
out: &mut MaybeUninit<AtomicI16>
)
[src]
&self,
_pos: usize,
_resolver: AtomicResolver,
out: &mut MaybeUninit<AtomicI16>
)
impl Archive for AtomicI32
[src]
impl Archive for AtomicI32
[src]type Archived = Self
type Resolver = AtomicResolver
fn resolve(
&self,
_pos: usize,
_resolver: AtomicResolver,
out: &mut MaybeUninit<AtomicI32>
)
[src]
&self,
_pos: usize,
_resolver: AtomicResolver,
out: &mut MaybeUninit<AtomicI32>
)
impl Archive for AtomicI64
[src]
impl Archive for AtomicI64
[src]type Archived = Self
type Resolver = AtomicResolver
fn resolve(
&self,
_pos: usize,
_resolver: AtomicResolver,
out: &mut MaybeUninit<AtomicI64>
)
[src]
&self,
_pos: usize,
_resolver: AtomicResolver,
out: &mut MaybeUninit<AtomicI64>
)
impl Archive for AtomicU8
[src]
impl Archive for AtomicU8
[src]type Archived = Self
type Resolver = AtomicResolver
fn resolve(
&self,
_pos: usize,
_resolver: AtomicResolver,
out: &mut MaybeUninit<AtomicU8>
)
[src]
&self,
_pos: usize,
_resolver: AtomicResolver,
out: &mut MaybeUninit<AtomicU8>
)
impl Archive for AtomicU16
[src]
impl Archive for AtomicU16
[src]type Archived = Self
type Resolver = AtomicResolver
fn resolve(
&self,
_pos: usize,
_resolver: AtomicResolver,
out: &mut MaybeUninit<AtomicU16>
)
[src]
&self,
_pos: usize,
_resolver: AtomicResolver,
out: &mut MaybeUninit<AtomicU16>
)
impl Archive for AtomicU32
[src]
impl Archive for AtomicU32
[src]type Archived = Self
type Resolver = AtomicResolver
fn resolve(
&self,
_pos: usize,
_resolver: AtomicResolver,
out: &mut MaybeUninit<AtomicU32>
)
[src]
&self,
_pos: usize,
_resolver: AtomicResolver,
out: &mut MaybeUninit<AtomicU32>
)
impl Archive for AtomicU64
[src]
impl Archive for AtomicU64
[src]type Archived = Self
type Resolver = AtomicResolver
fn resolve(
&self,
_pos: usize,
_resolver: AtomicResolver,
out: &mut MaybeUninit<AtomicU64>
)
[src]
&self,
_pos: usize,
_resolver: AtomicResolver,
out: &mut MaybeUninit<AtomicU64>
)
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]
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 resolve(
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
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]
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 resolve(
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
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]
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 resolve(
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
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]
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 resolve(
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
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]
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 resolve(
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
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]
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 resolve(
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
impl<T5: Archive, T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Archive for (T5, T4, T3, T2, T1, T0)
[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 resolve(
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
impl<T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Archive for (T4, T3, T2, T1, T0)
[src]
impl<T4: Archive, T3: Archive, T2: Archive, T1: Archive, T0: Archive> Archive for (T4, T3, T2, T1, T0)
[src]impl<K: Archive + Hash + Eq, V: Archive, S> Archive for HashMap<K, V, S> where
K::Archived: Hash + Eq,
[src]
impl<K: Archive + Hash + Eq, V: Archive, S> Archive for HashMap<K, V, S> where
K::Archived: Hash + Eq,
[src]type Archived = ArchivedHashMap<K::Archived, V::Archived>
type Resolver = ArchivedHashMapResolver
fn resolve(
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
impl<K: Archive + Hash + Eq> Archive for HashSet<K> where
K::Archived: Hash + Eq,
[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 resolve(
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
impl Archive for Ipv4Addr
[src]
impl Archive for Ipv4Addr
[src]type Archived = ArchivedIpv4Addr
type Resolver = ()
fn resolve(
&self,
_: usize,
_: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]
&self,
_: usize,
_: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
impl Archive for Ipv6Addr
[src]
impl Archive for Ipv6Addr
[src]type Archived = ArchivedIpv6Addr
type Resolver = ()
fn resolve(
&self,
_: usize,
_: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]
&self,
_: usize,
_: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
impl Archive for IpAddr
[src]
impl Archive for IpAddr
[src]type Archived = ArchivedIpAddr
type Resolver = ()
fn resolve(
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
impl Archive for SocketAddrV4
[src]
impl Archive for SocketAddrV4
[src]type Archived = ArchivedSocketAddrV4
type Resolver = ()
fn resolve(
&self,
pos: usize,
_: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]
&self,
pos: usize,
_: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
impl Archive for SocketAddrV6
[src]
impl Archive for SocketAddrV6
[src]type Archived = ArchivedSocketAddrV6
type Resolver = ()
fn resolve(
&self,
pos: usize,
_: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]
&self,
pos: usize,
_: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
impl Archive for SocketAddr
[src]
impl Archive for SocketAddr
[src]type Archived = ArchivedSocketAddr
type Resolver = ()
fn resolve(
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
impl<T: ArchiveUnsized + ?Sized> Archive for Rc<T>
[src]
impl<T: ArchiveUnsized + ?Sized> Archive for Rc<T>
[src]type Archived = ArchivedRc<T::Archived>
type Resolver = RcResolver<T::MetadataResolver>
fn resolve(
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
impl<T: ArchiveUnsized + ?Sized> Archive for Weak<T>
[src]
impl<T: ArchiveUnsized + ?Sized> Archive for Weak<T>
[src]type Archived = ArchivedRcWeak<T::Archived>
type Resolver = RcWeakResolver<T::MetadataResolver>
fn resolve(
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
impl<T: ArchiveUnsized + ?Sized> Archive for Arc<T>
[src]
impl<T: ArchiveUnsized + ?Sized> Archive for Arc<T>
[src]type Archived = ArchivedArc<T::Archived>
type Resolver = ArcResolver<T::MetadataResolver>
fn resolve(
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
impl<T: ArchiveUnsized + ?Sized> Archive for Weak<T>
[src]
impl<T: ArchiveUnsized + ?Sized> Archive for Weak<T>
[src]type Archived = ArchivedArcWeak<T::Archived>
type Resolver = ArcWeakResolver<T::MetadataResolver>
fn resolve(
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
impl Archive for String
[src]
impl Archive for String
[src]type Archived = ArchivedString
type Resolver = StringResolver
fn resolve(
&self,
pos: usize,
resolver: StringResolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]
&self,
pos: usize,
resolver: StringResolver,
out: &mut MaybeUninit<Self::Archived>
)
impl<T: ArchiveUnsized + ?Sized> Archive for Box<T>
[src]
impl<T: ArchiveUnsized + ?Sized> Archive for Box<T>
[src]type Archived = ArchivedBox<T::Archived>
type Resolver = BoxResolver<T::MetadataResolver>
fn resolve(
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
impl<T: Archive> Archive for Vec<T>
[src]
impl<T: Archive> Archive for Vec<T>
[src]type Archived = ArchivedVec<T::Archived>
type Resolver = VecResolver<MetadataResolver<[T]>>
fn resolve(
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)
[src]
&self,
pos: usize,
resolver: Self::Resolver,
out: &mut MaybeUninit<Self::Archived>
)