Struct rkyv::with::With

#[repr(transparent)]
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::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<'a, T: Archive> ArchiveWith<With<&'a [T], RefAsBox>> for CopyOptimize

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

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

type Resolver = BoxResolver<MetadataResolver<[T]>>

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

Performs the conversion.

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<F, W, T, D> Deserialize<With<T, W>, D> for F where
    F: ?Sized,
    W: DeserializeWith<F, T, D>,
    D: Fallible + ?Sized, 

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.

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

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.