rspack_cacheable 0.100.0-rc.2

rspack_cacheable
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

use rkyv::{
  Archive, Archived, Deserialize, Place, Resolver, Serialize,
  de::Pooling,
  rancor::Fallible,
  ser::Sharing,
  with::{ArchiveWith, DeserializeWith, SerializeWith},
};

use crate::{Error, Result, context::ContextGuard};

pub trait AsConverter<T> {
  fn serialize(data: &T, guard: &ContextGuard) -> Result<Self>
  where
    Self: Sized;
  fn deserialize(self, guard: &ContextGuard) -> Result<T>;
}

pub struct As<A> {
  _inner: A,
}

pub struct AsResolver<A: Archive> {
  resolver: Resolver<A>,
  value: A,
}

impl<T, A> ArchiveWith<T> for As<A>
where
  A: AsConverter<T> + Archive,
{
  type Archived = Archived<A>;
  type Resolver = AsResolver<A>;

  #[inline]
  fn resolve_with(_field: &T, resolver: Self::Resolver, out: Place<Self::Archived>) {
    let AsResolver { resolver, value } = resolver;
    value.resolve(resolver, out)
  }
}

impl<T, A, S> SerializeWith<T, S> for As<A>
where
  A: AsConverter<T> + Archive + Serialize<S>,
  S: Fallible<Error = Error> + Sharing + ?Sized,
{
  #[inline]
  fn serialize_with(field: &T, serializer: &mut S) -> Result<Self::Resolver> {
    let guard = ContextGuard::sharing_guard(serializer)?;
    let value = <A as AsConverter<T>>::serialize(field, guard)?;
    Ok(AsResolver {
      resolver: value.serialize(serializer)?,
      value,
    })
  }
}

impl<T, A, D> DeserializeWith<Archived<A>, T, D> for As<A>
where
  A: AsConverter<T> + Archive,
  A::Archived: Deserialize<A, D>,
  D: Fallible<Error = Error> + Pooling + ?Sized,
{
  #[inline]
  fn deserialize_with(field: &Archived<A>, de: &mut D) -> Result<T> {
    let field = A::Archived::deserialize(field, de)?;
    let guard = ContextGuard::pooling_guard(de)?;
    field.deserialize(guard)
  }
}