rspack_cacheable 0.102.3

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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

use rspack_intern::{Atom, AtomMap, AtomSet, IndexAtomMap, IndexAtomSet};

use super::AsPreset;
use crate::{
  Result,
  rkyv::{
    Place,
    rancor::{Fallible, Source},
    ser::Writer,
    string::{ArchivedString, StringResolver},
    with::{ArchiveWith, DeserializeWith, SerializeWith},
  },
  with::{AsMapConverter, AsVecConverter},
};

impl ArchiveWith<Atom> for AsPreset {
  type Archived = ArchivedString;
  type Resolver = StringResolver;

  #[inline]
  fn resolve_with(field: &Atom, resolver: Self::Resolver, out: Place<Self::Archived>) {
    ArchivedString::resolve_from_str(field.as_str(), resolver, out);
  }
}

impl<S> SerializeWith<Atom, S> for AsPreset
where
  S: ?Sized + Fallible + Writer,
  S::Error: Source,
{
  #[inline]
  fn serialize_with(field: &Atom, serializer: &mut S) -> Result<Self::Resolver, S::Error> {
    ArchivedString::serialize_from_str(field.as_str(), serializer)
  }
}

impl<D> DeserializeWith<ArchivedString, Atom, D> for AsPreset
where
  D: ?Sized + Fallible,
{
  #[inline]
  fn deserialize_with(field: &ArchivedString, _: &mut D) -> Result<Atom, D::Error> {
    Ok(Atom::from(field.as_str()))
  }
}

macro_rules! impl_atom_set_converter {
  ($type:ty) => {
    impl AsVecConverter for $type {
      type Item = Atom;

      fn len(&self) -> usize {
        std::ops::Deref::deref(self).len()
      }

      fn iter(&self) -> impl Iterator<Item = &Self::Item> {
        std::ops::Deref::deref(self).iter()
      }

      fn from(data: impl Iterator<Item = Result<Self::Item>>) -> Result<Self> {
        Ok(data.collect::<Result<Vec<_>>>()?.into_iter().collect())
      }
    }
  };
}

impl_atom_set_converter!(AtomSet);
impl_atom_set_converter!(IndexAtomSet);

macro_rules! impl_atom_map_converter {
  ($type:ident) => {
    impl<V> AsMapConverter for $type<V> {
      type Key = Atom;
      type Value = V;

      fn len(&self) -> usize {
        std::ops::Deref::deref(self).len()
      }

      fn iter(&self) -> impl Iterator<Item = (&Self::Key, &Self::Value)> {
        std::ops::Deref::deref(self).iter()
      }

      fn from(data: impl Iterator<Item = Result<(Self::Key, Self::Value)>>) -> Result<Self> {
        Ok(data.collect::<Result<Vec<_>>>()?.into_iter().collect())
      }
    }
  };
}

impl_atom_map_converter!(AtomMap);
impl_atom_map_converter!(IndexAtomMap);