Struct rkyv::with::With

#[repr(transparent)]
pub struct With<F: ?Sized, W> { /* fields omitted */ }

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 With wrapper and serialized instead (i.e. &With<T, Wrapper>). 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::Archived

The archived representation of this type.

type Resolver = W::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<F: ?Sized, W> AsRef<F> for With<F, W>

fn as_ref(&self) -> &F

Performs the conversion.

impl<F, W, T, D: ?Sized> Deserialize<With<T, W>, D> for F where
    F: ?Sized,
    W: DeserializeWith<F, T, D>,
    D: Fallible, 

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

Deserializes using the given deserializer

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.