Struct rkyv::with::Lock

pub struct Lock;

A wrapper that locks a lock and serializes the value immutably.

This wrapper can panic under very specific circumstances when:

1. serialize_with is called and succeeds in locking the value to serialize it.
2. Another thread locks the value and panics, poisoning the lock
3. resolve_with is called and gets a poisoned value.

Unfortunately, it’s not possible to work around this issue. If your code absolutely must not panic under any circumstances, it’s recommended that you lock your values and then serialize them while locked.

Additionally, mutating the data protected by a mutex between the serialize and resolve steps may cause undefined behavior in the resolve step. Uses of this wrapper should be considered unsafe with the requirement that the data not be mutated between these two steps.

Regular serializers don’t support the custom error handling needed for this type by default. To use this wrapper, a custom serializer with an error type satisfying <S as Fallible>::Error: From<LockError> must be provided.

Example

use std::sync::Mutex;
use rkyv::{Archive, with::Lock};

#[derive(Archive)]
struct Example {
    #[with(Lock)]
    a: Mutex<i32>,
}

Trait Implementations

impl<F: Archive> ArchiveWith<Mutex<F>> for Lock

type Archived = Immutable<<F as Archive>::Archived>

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

type Resolver = <F as Archive>::Resolver

The resolver of a With<F, Self>.

unsafe fn resolve_with( field: &Mutex<F>, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived )

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

impl<F: Archive> ArchiveWith<RwLock<F>> for Lock

type Archived = Immutable<<F as Archive>::Archived>

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

type Resolver = <F as Archive>::Resolver

The resolver of a With<F, Self>.

unsafe fn resolve_with( field: &RwLock<F>, pos: usize, resolver: Self::Resolver, out: *mut Self::Archived )

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

impl Debug for Lock

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

Formats the value using the given formatter.

impl<F, T, D> DeserializeWith<Immutable<F>, Mutex<T>, D> for Lock

where F: Deserialize<T, D>, D: Fallible + ?Sized,

fn deserialize_with( field: &Immutable<F>, deserializer: &mut D ) -> Result<Mutex<T>, D::Error>

Deserializes the field type F using the given deserializer.

impl<F, T, D> DeserializeWith<Immutable<F>, RwLock<T>, D> for Lock

where F: Deserialize<T, D>, D: Fallible + ?Sized,

fn deserialize_with( field: &Immutable<F>, deserializer: &mut D ) -> Result<RwLock<T>, D::Error>

Deserializes the field type F using the given deserializer.

impl<F: Serialize<S>, S: Fallible + ?Sized> SerializeWith<Mutex<F>, S> for Lock

where S::Error: From<LockError>,

fn serialize_with( field: &Mutex<F>, serializer: &mut S ) -> Result<Self::Resolver, S::Error>

Serializes the field type F using the given serializer.

impl<F: Serialize<S>, S: Fallible + ?Sized> SerializeWith<RwLock<F>, S> for Lock

where S::Error: From<LockError>,

fn serialize_with( field: &RwLock<F>, serializer: &mut S ) -> Result<Self::Resolver, S::Error>

Serializes the field type F using the given serializer.