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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use std::hash::BuildHasherDefault;

use rkyv::{
  Place,
  rancor::{Fallible, Source},
  ser::Writer,
  string::{ArchivedString, StringResolver},
  with::{ArchiveWith, DeserializeWith, SerializeWith},
};
use rustc_hash::FxHasher;

pub struct AsRefStr;

pub trait AsRefStrConverter {
  fn as_str(&self) -> &str;
  fn from_str(s: &str) -> Self
  where
    Self: Sized;
}

impl<T> ArchiveWith<T> for AsRefStr
where
  T: AsRefStrConverter,
{
  type Archived = ArchivedString;
  type Resolver = StringResolver;

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

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

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

// for Cow<'static, str>
impl AsRefStrConverter for std::borrow::Cow<'static, str> {
  fn as_str(&self) -> &str {
    self.as_ref()
  }
  fn from_str(s: &str) -> Self
  where
    Self: Sized,
  {
    Self::from(String::from(s))
  }
}

// for Arc<str>
use std::sync::{Arc, LazyLock};

use dashmap::DashSet;

#[cfg_attr(allocative, allocative::root)]
pub static CACHED_ARC_STR: LazyLock<DashSet<Arc<str>, BuildHasherDefault<FxHasher>>> =
  LazyLock::new(Default::default);

impl AsRefStrConverter for Arc<str> {
  fn as_str(&self) -> &str {
    self.as_ref()
  }
  fn from_str(s: &str) -> Self
  where
    Self: Sized,
  {
    if let Some(cached_str) = CACHED_ARC_STR.get(s) {
      cached_str.clone()
    } else {
      let s: Arc<str> = Arc::from(s);
      CACHED_ARC_STR.insert(s.clone());
      s
    }
  }
}

// for Box<str>
impl AsRefStrConverter for Box<str> {
  fn as_str(&self) -> &str {
    self
  }
  fn from_str(s: &str) -> Self
  where
    Self: Sized,
  {
    s.into()
  }
}

// for Ustr
impl AsRefStrConverter for ustr::Ustr {
  fn as_str(&self) -> &str {
    self
  }
  fn from_str(s: &str) -> Self
  where
    Self: Sized,
  {
    s.into()
  }
}