Trait ArchiveWith

Source

pub trait ArchiveWith<F: ?Sized> {
    type Archived: Portable;
    type Resolver;

    // Required method
    fn resolve_with(
        field: &F,
        resolver: Self::Resolver,
        out: Place<Self::Archived>,
    );
}

Expand description

A variant of Archive that works with wrappers.

Creating a wrapper allows users to customize how fields are archived easily without changing the unarchived type.

This trait allows wrapper types to transparently change the archive behaviors for struct and enum fields. When a field is serialized, it may use the implementations for the wrapper type and the given field instead of the implementation for the type itself.

Only a single implementation of Archive may be written for each type, but multiple implementations of ArchiveWith can be written for the same type because it is parametric over the wrapper type. This is used with the #[rkyv(with = ..)] macro attribute to provide a more flexible interface for serialization.

§Example

use rkyv::{
    access_unchecked, deserialize,
    rancor::{Error, Fallible, Infallible, ResultExt as _},
    to_bytes,
    with::{ArchiveWith, DeserializeWith, SerializeWith},
    Archive, Archived, Deserialize, Place, Resolver, Serialize,
};

struct Incremented;

impl ArchiveWith<i32> for Incremented {
    type Archived = Archived<i32>;
    type Resolver = Resolver<i32>;

    fn resolve_with(field: &i32, _: (), out: Place<Self::Archived>) {
        let incremented = field + 1;
        incremented.resolve((), out);
    }
}

impl<S> SerializeWith<i32, S> for Incremented
where
    S: Fallible + ?Sized,
    i32: Serialize<S>,
{
    fn serialize_with(
        field: &i32,
        serializer: &mut S,
    ) -> Result<Self::Resolver, S::Error> {
        let incremented = field + 1;
        incremented.serialize(serializer)
    }
}

impl<D> DeserializeWith<Archived<i32>, i32, D> for Incremented
where
    D: Fallible + ?Sized,
    Archived<i32>: Deserialize<i32, D>,
{
    fn deserialize_with(
        field: &Archived<i32>,
        deserializer: &mut D,
    ) -> Result<i32, D::Error> {
        Ok(field.deserialize(deserializer)? - 1)
    }
}

#[derive(Archive, Deserialize, Serialize)]
struct Example {
    #[rkyv(with = Incremented)]
    a: i32,
    // Another i32 field, but not incremented this time
    b: i32,
}

let value = Example { a: 4, b: 9 };

let buf = to_bytes::<Error>(&value).unwrap();

let archived =
    unsafe { access_unchecked::<Archived<Example>>(buf.as_ref()) };
// The wrapped field has been incremented
assert_eq!(archived.a, 5);
// ... and the unwrapped field has not
assert_eq!(archived.b, 9);

let deserialized = deserialize::<Example, Infallible>(archived).always_ok();
// The wrapped field is back to normal
assert_eq!(deserialized.a, 4);
// ... and the unwrapped field is unchanged
assert_eq!(deserialized.b, 9);

Required Associated Types§

Source

type Archived: Portable

The archived type of Self with F.

Source

type Resolver

The resolver of a Self with F.

Required Methods§

Source

fn resolve_with(field: &F, resolver: Self::Resolver, out: Place<Self::Archived>)

Resolves the archived type using a reference to the field type F.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Trait ArchiveWithCopy item path

§Example

Required Associated Types§

type Archived: Portable

type Resolver

Required Methods§

fn resolve_with(field: &F, resolver: Self::Resolver, out: Place<Self::Archived>)

Dyn Compatibility§

Implementors§

impl ArchiveWith<Option<NonZero<i8>>> for Niche

type Archived = ArchivedOptionNonZeroI8

type Resolver = ()

impl ArchiveWith<Option<NonZero<i16>>> for Niche

type Archived = ArchivedOptionNonZeroI16

type Resolver = ()

impl ArchiveWith<Option<NonZero<i32>>> for Niche

type Archived = ArchivedOptionNonZeroI32

type Resolver = ()

impl ArchiveWith<Option<NonZero<i64>>> for Niche

type Archived = ArchivedOptionNonZeroI64

type Resolver = ()

impl ArchiveWith<Option<NonZero<i128>>> for Niche

type Archived = ArchivedOptionNonZeroI128

type Resolver = ()

impl ArchiveWith<Option<NonZero<isize>>> for Niche

type Archived = ArchivedOptionNonZeroI32

type Resolver = ()

impl ArchiveWith<Option<NonZero<u8>>> for Niche

type Archived = ArchivedOptionNonZeroU8

type Resolver = ()

impl ArchiveWith<Option<NonZero<u16>>> for Niche

type Archived = ArchivedOptionNonZeroU16

type Resolver = ()

impl ArchiveWith<Option<NonZero<u32>>> for Niche

type Archived = ArchivedOptionNonZeroU32

type Resolver = ()

impl ArchiveWith<Option<NonZero<u64>>> for Niche

type Archived = ArchivedOptionNonZeroU64

type Resolver = ()

impl ArchiveWith<Option<NonZero<u128>>> for Niche

type Archived = ArchivedOptionNonZeroU128

type Resolver = ()

impl ArchiveWith<Option<NonZero<usize>>> for Niche

type Archived = ArchivedOptionNonZeroU32

type Resolver = ()

impl ArchiveWith<OsString> for AsString

type Archived = ArchivedString

type Resolver = StringResolver

impl ArchiveWith<PathBuf> for AsString

type Archived = ArchivedString

type Resolver = StringResolver

impl ArchiveWith<SystemTime> for AsUnixTime

type Archived = ArchivedDuration

type Resolver = ()

impl<'a> ArchiveWith<Cow<'a, str>> for AsOwned

type Archived = ArchivedString

type Resolver = StringResolver

impl<'a> ArchiveWith<Cow<'a, CStr>> for AsOwned

type Archived = ArchivedCString

type Resolver = CStringResolver

impl<'a, F: Archive + Clone> ArchiveWith<Cow<'a, F>> for AsOwned

type Archived = <F as Archive>::Archived

type Resolver = <F as Archive>::Resolver

impl<'a, T: Archive + Clone> ArchiveWith<Cow<'a, [T]>> for AsOwned

type Archived = ArchivedVec<<T as Archive>::Archived>

type Resolver = VecResolver

impl<A, B, K, V> ArchiveWith<BTreeMap<K, V>> for MapKV<A, B>where A: ArchiveWith<K>, B: ArchiveWith<V>,

type Archived = ArchivedBTreeMap<<A as ArchiveWith<K>>::Archived, <B as ArchiveWith<V>>::Archived>

type Resolver = BTreeMapResolver

impl<A, B, K, V, H> ArchiveWith<HashMap<K, V, H>> for MapKV<A, B>where A: ArchiveWith<K>, B: ArchiveWith<V>, H: Default + BuildHasher,

type Archived = ArchivedHashMap<<A as ArchiveWith<K>>::Archived, <B as ArchiveWith<V>>::Archived>

type Resolver = HashMapResolver

impl<A, O> ArchiveWith<Option<O>> for Map<A>where A: ArchiveWith<O>,

type Archived = ArchivedOption<<A as ArchiveWith<O>>::Archived>

type Resolver = Option<<A as ArchiveWith<O>>::Resolver>

impl<A, O> ArchiveWith<Vec<O>> for Map<A>where A: ArchiveWith<O>,

type Archived = ArchivedVec<<A as ArchiveWith<O>>::Archived>

type Resolver = VecResolver

impl<F> ArchiveWith<F> for Skip

type Archived = ()

Trait ArchiveWith

impl<A, B, K, V> ArchiveWith<BTreeMap<K, V>> for MapKV<A, B>
where A: ArchiveWith<K>, B: ArchiveWith<V>,

impl<A, B, K, V, H> ArchiveWith<HashMap<K, V, H>> for MapKV<A, B>
where A: ArchiveWith<K>, B: ArchiveWith<V>, H: Default + BuildHasher,

impl<A, O> ArchiveWith<Option<O>> for Map<A>
where A: ArchiveWith<O>,

impl<A, O> ArchiveWith<Vec<O>> for Map<A>
where A: ArchiveWith<O>,