Struct rkyv::with::With

pub struct With<F: ?Sized, W> { /* private fields */ }

A transparent wrapper for archived fields.

This is used by the #[with(...)] attribute in the Archive macro to create transparent serialization wrappers. Those wrappers leverage ArchiveWith to change how the type is archived, serialized, and deserialized.

When a field is serialized, a reference to the field (i.e. &T) can be cast to a reference to a wrapping With (i.e. With<T, Wrapper>) and serialized instead. This is safe to do because With is a transparent wrapper and is shaped exactly the same as the underlying field.

Example

use rkyv::{Archive, with::Inline};

#[derive(Archive)]
struct Example<'a> {
    // This will archive as if it were With<&'a i32, Inline>. That will delegate the archival
    // to the ArchiveWith implementation of Inline for &T.
    #[with(Inline)]
    a: &'a i32,
}

Implementations

impl<F: ?Sized, W> With<F, W>

pub fn cast(field: &F) -> &With<F, W>

Casts a With reference from a reference to the underlying field.

This is always safe to do because With is a transparent wrapper.

impl<F, W> With<F, W>

pub fn into_inner(self) -> F

Unwraps a With into the underlying field.

Trait Implementations

impl<F: ?Sized, W: ArchiveWith<F>> Archive for With<F, W>

type Archived = <W as ArchiveWith<F>>::Archived

The archived representation of this type.

type Resolver = <W as ArchiveWith<F>>::Resolver

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

unsafe fn resolve( &self, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived )

Creates the archived version of this value at the given position and writes it to the given output.

impl<'a, T: Archive> ArchiveWith<With<&'a [T], RefAsBox>> for CopyOptimize

type Archived = ArchivedBox<[<T as Archive>::Archived]>

The archived type of a With<F, Self>.

type Resolver = BoxResolver<<[T] as ArchiveUnsized>::MetadataResolver>

The resolver of a With<F, Self>.

unsafe fn resolve_with( field: &With<&'a [T], RefAsBox>, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived )

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

impl<F: ?Sized, W> AsRef<F> for With<F, W>

fn as_ref(&self) -> &F

Converts this type into a shared reference of the (usually inferred) input type.

impl<F: Debug + ?Sized, W: Debug> Debug for With<F, W>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<D: Fallible + ?Sized> DeserializeWith<<With<AtomicI16, Atomic> as Archive>::Archived, AtomicI16, D> for Atomic

fn deserialize_with( field: &Archived<With<AtomicI16, Self>>, _: &mut D ) -> Result<AtomicI16, D::Error>

Deserializes the field type F using the given deserializer.

impl<D: Fallible + ?Sized> DeserializeWith<<With<AtomicI32, Atomic> as Archive>::Archived, AtomicI32, D> for Atomic

fn deserialize_with( field: &Archived<With<AtomicI32, Self>>, _: &mut D ) -> Result<AtomicI32, D::Error>

Deserializes the field type F using the given deserializer.

impl<D: Fallible + ?Sized> DeserializeWith<<With<AtomicI64, Atomic> as Archive>::Archived, AtomicI64, D> for Atomic

fn deserialize_with( field: &Archived<With<AtomicI64, Self>>, _: &mut D ) -> Result<AtomicI64, D::Error>

Deserializes the field type F using the given deserializer.

impl<D: Fallible + ?Sized> DeserializeWith<<With<AtomicIsize, Atomic> as Archive>::Archived, AtomicIsize, D> for Atomic

fn deserialize_with( field: &Archived<With<AtomicIsize, Self>>, _: &mut D ) -> Result<AtomicIsize, D::Error>

Deserializes the field type F using the given deserializer.

impl<D: Fallible + ?Sized> DeserializeWith<<With<AtomicU16, Atomic> as Archive>::Archived, AtomicU16, D> for Atomic

fn deserialize_with( field: &Archived<With<AtomicU16, Self>>, _: &mut D ) -> Result<AtomicU16, D::Error>

Deserializes the field type F using the given deserializer.

impl<D: Fallible + ?Sized> DeserializeWith<<With<AtomicU32, Atomic> as Archive>::Archived, AtomicU32, D> for Atomic

fn deserialize_with( field: &Archived<With<AtomicU32, Self>>, _: &mut D ) -> Result<AtomicU32, D::Error>

Deserializes the field type F using the given deserializer.

impl<D: Fallible + ?Sized> DeserializeWith<<With<AtomicU64, Atomic> as Archive>::Archived, AtomicU64, D> for Atomic

fn deserialize_with( field: &Archived<With<AtomicU64, Self>>, _: &mut D ) -> Result<AtomicU64, D::Error>

Deserializes the field type F using the given deserializer.

impl<F: ?Sized, W: SerializeWith<F, S>, S: Fallible + ?Sized> Serialize<S> for With<F, W>

fn serialize(&self, serializer: &mut S) -> Result<Self::Resolver, S::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl<'a, T, S> SerializeWith<With<&'a [T], RefAsBox>, S> for CopyOptimize

where T: Serialize<S>, S: Serializer + ?Sized,

fn serialize_with( field: &With<&'a [T], RefAsBox>, serializer: &mut S ) -> Result<Self::Resolver, S::Error>

Serializes the field type F using the given serializer.