jacquard_common/
cowstr.rs

1use serde::{Deserialize, Serialize};
2use smol_str::SmolStr;
3use std::{
4    borrow::Cow,
5    fmt,
6    hash::{Hash, Hasher},
7    ops::Deref,
8};
9
10use crate::IntoStatic;
11
12/// A copy-on-write immutable string type that uses [`SmolStr`] for
13/// the "owned" variant.
14///
15/// The standard [`Cow`] type cannot be used, since
16/// `<str as ToOwned>::Owned` is `String`, and not `SmolStr`.
17///
18/// Shamelessly ported from [merde](https://github.com/bearcove/merde)
19#[derive(Clone)]
20pub enum CowStr<'s> {
21    /// &str varaiant
22    Borrowed(&'s str),
23    /// Smolstr variant
24    Owned(SmolStr),
25}
26
27impl CowStr<'static> {
28    /// Create a new `CowStr` by copying from a `&str` — this might allocate
29    /// if the string is longer than `MAX_INLINE_SIZE`.
30    pub fn copy_from_str(s: &str) -> Self {
31        Self::Owned(SmolStr::from(s))
32    }
33
34    /// Create a new owned `CowStr` from a static &str without allocating
35    pub fn new_static(s: &'static str) -> Self {
36        Self::Owned(SmolStr::new_static(s))
37    }
38}
39
40impl<'s> CowStr<'s> {
41    #[inline]
42    /// Borrow and decode a byte slice as utf8 into a CowStr
43    pub fn from_utf8(s: &'s [u8]) -> Result<Self, std::str::Utf8Error> {
44        Ok(Self::Borrowed(std::str::from_utf8(s)?))
45    }
46
47    #[inline]
48    /// Take bytes and decode them as utf8 into an owned CowStr. Might allocate.
49    pub fn from_utf8_owned(s: impl AsRef<[u8]>) -> Result<Self, std::str::Utf8Error> {
50        Ok(Self::Owned(SmolStr::new(std::str::from_utf8(&s.as_ref())?)))
51    }
52
53    #[inline]
54    /// Take bytes and decode them as utf8, skipping invalid characters, taking ownership.
55    /// Will allocate, uses String::from_utf8_lossy() internally for now.
56    pub fn from_utf8_lossy(s: &'s [u8]) -> Self {
57        Self::Owned(String::from_utf8_lossy(&s).into())
58    }
59
60    /// # Safety
61    ///
62    /// This function is unsafe because it does not check that the bytes are valid UTF-8.
63    #[inline]
64    pub unsafe fn from_utf8_unchecked(s: &'s [u8]) -> Self {
65        unsafe { Self::Owned(SmolStr::new(std::str::from_utf8_unchecked(s))) }
66    }
67
68    /// Returns a reference to the underlying string slice.
69    #[inline]
70    pub fn as_str(&self) -> &str {
71        match self {
72            CowStr::Borrowed(s) => s,
73            CowStr::Owned(s) => s.as_str(),
74        }
75    }
76}
77
78impl AsRef<str> for CowStr<'_> {
79    #[inline]
80    fn as_ref(&self) -> &str {
81        match self {
82            CowStr::Borrowed(s) => s,
83            CowStr::Owned(s) => s.as_str(),
84        }
85    }
86}
87
88impl Deref for CowStr<'_> {
89    type Target = str;
90
91    #[inline]
92    fn deref(&self) -> &Self::Target {
93        match self {
94            CowStr::Borrowed(s) => s,
95            CowStr::Owned(s) => s.as_str(),
96        }
97    }
98}
99
100impl<'a> From<Cow<'a, str>> for CowStr<'a> {
101    #[inline]
102    fn from(s: Cow<'a, str>) -> Self {
103        match s {
104            Cow::Borrowed(s) => CowStr::Borrowed(s),
105            #[allow(clippy::useless_conversion)]
106            Cow::Owned(s) => CowStr::Owned(s.into()),
107        }
108    }
109}
110
111impl<'s> From<&'s str> for CowStr<'s> {
112    #[inline]
113    fn from(s: &'s str) -> Self {
114        CowStr::Borrowed(s)
115    }
116}
117
118impl Default for CowStr<'_> {
119    #[inline]
120    fn default() -> Self {
121        CowStr::new_static("")
122    }
123}
124
125impl From<String> for CowStr<'_> {
126    #[inline]
127    fn from(s: String) -> Self {
128        #[allow(clippy::useless_conversion)]
129        CowStr::Owned(s.into())
130    }
131}
132
133impl From<Box<str>> for CowStr<'_> {
134    #[inline]
135    fn from(s: Box<str>) -> Self {
136        CowStr::Owned(s.into())
137    }
138}
139
140impl<'s> From<&'s String> for CowStr<'s> {
141    #[inline]
142    fn from(s: &'s String) -> Self {
143        CowStr::Borrowed(s.as_str())
144    }
145}
146
147impl From<CowStr<'_>> for String {
148    #[inline]
149    fn from(s: CowStr<'_>) -> Self {
150        match s {
151            CowStr::Borrowed(s) => s.into(),
152            #[allow(clippy::useless_conversion)]
153            CowStr::Owned(s) => s.into(),
154        }
155    }
156}
157
158impl From<CowStr<'_>> for SmolStr {
159    #[inline]
160    fn from(s: CowStr<'_>) -> Self {
161        match s {
162            CowStr::Borrowed(s) => SmolStr::new(s),
163            CowStr::Owned(s) => SmolStr::new(s),
164        }
165    }
166}
167
168impl From<SmolStr> for CowStr<'_> {
169    #[inline]
170    fn from(s: SmolStr) -> Self {
171        CowStr::Owned(s)
172    }
173}
174
175impl From<CowStr<'_>> for Box<str> {
176    #[inline]
177    fn from(s: CowStr<'_>) -> Self {
178        match s {
179            CowStr::Borrowed(s) => s.into(),
180            CowStr::Owned(s) => String::from(s).into_boxed_str(),
181        }
182    }
183}
184
185impl<'a> PartialEq<CowStr<'a>> for CowStr<'_> {
186    #[inline]
187    fn eq(&self, other: &CowStr<'a>) -> bool {
188        self.deref() == other.deref()
189    }
190}
191
192impl PartialEq<&str> for CowStr<'_> {
193    #[inline]
194    fn eq(&self, other: &&str) -> bool {
195        self.deref() == *other
196    }
197}
198
199impl PartialEq<CowStr<'_>> for &str {
200    #[inline]
201    fn eq(&self, other: &CowStr<'_>) -> bool {
202        *self == other.deref()
203    }
204}
205
206impl PartialEq<String> for CowStr<'_> {
207    #[inline]
208    fn eq(&self, other: &String) -> bool {
209        self.deref() == other.as_str()
210    }
211}
212
213impl PartialEq<CowStr<'_>> for String {
214    #[inline]
215    fn eq(&self, other: &CowStr<'_>) -> bool {
216        self.as_str() == other.deref()
217    }
218}
219
220impl PartialOrd for CowStr<'_> {
221    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
222        Some(match (self, other) {
223            (CowStr::Borrowed(s1), CowStr::Borrowed(s2)) => s1.cmp(s2),
224            (CowStr::Borrowed(s1), CowStr::Owned(s2)) => s1.cmp(&s2.as_ref()),
225            (CowStr::Owned(s1), CowStr::Borrowed(s2)) => s1.as_str().cmp(s2),
226            (CowStr::Owned(s1), CowStr::Owned(s2)) => s1.cmp(s2),
227        })
228    }
229}
230
231impl Ord for CowStr<'_> {
232    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
233        match (self, other) {
234            (CowStr::Borrowed(s1), CowStr::Borrowed(s2)) => s1.cmp(s2),
235            (CowStr::Borrowed(s1), CowStr::Owned(s2)) => s1.cmp(&s2.as_ref()),
236            (CowStr::Owned(s1), CowStr::Borrowed(s2)) => s1.as_str().cmp(s2),
237            (CowStr::Owned(s1), CowStr::Owned(s2)) => s1.cmp(s2),
238        }
239    }
240}
241
242impl Eq for CowStr<'_> {}
243
244impl Hash for CowStr<'_> {
245    #[inline]
246    fn hash<H: Hasher>(&self, state: &mut H) {
247        self.deref().hash(state)
248    }
249}
250
251impl fmt::Debug for CowStr<'_> {
252    #[inline]
253    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
254        self.deref().fmt(f)
255    }
256}
257
258impl fmt::Display for CowStr<'_> {
259    #[inline]
260    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
261        self.deref().fmt(f)
262    }
263}
264
265impl IntoStatic for CowStr<'_> {
266    type Output = CowStr<'static>;
267
268    #[inline]
269    fn into_static(self) -> Self::Output {
270        match self {
271            CowStr::Borrowed(s) => CowStr::Owned((*s).into()),
272            CowStr::Owned(s) => CowStr::Owned(s),
273        }
274    }
275}
276
277impl Serialize for CowStr<'_> {
278    #[inline]
279    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
280    where
281        S: serde::Serializer,
282    {
283        serializer.serialize_str(self)
284    }
285}
286
287/// Deserialization helper for things that wrap a CowStr
288pub struct CowStrVisitor;
289
290impl<'de> serde::de::Visitor<'de> for CowStrVisitor {
291    type Value = CowStr<'de>;
292
293    #[inline]
294    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
295        write!(formatter, "a string")
296    }
297
298    #[inline]
299    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
300    where
301        E: serde::de::Error,
302    {
303        Ok(CowStr::copy_from_str(v))
304    }
305
306    #[inline]
307    fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
308    where
309        E: serde::de::Error,
310    {
311        Ok(CowStr::Borrowed(v))
312    }
313
314    #[inline]
315    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
316    where
317        E: serde::de::Error,
318    {
319        Ok(v.into())
320    }
321}
322
323impl<'de, 'a> Deserialize<'de> for CowStr<'a>
324where
325    'de: 'a,
326{
327    #[inline]
328    fn deserialize<D>(deserializer: D) -> Result<CowStr<'a>, D::Error>
329    where
330        D: serde::Deserializer<'de>,
331    {
332        deserializer.deserialize_str(CowStrVisitor)
333    }
334}
335
336/// Convert to a CowStr.
337pub trait ToCowStr {
338    /// Convert to a CowStr.
339    fn to_cowstr(&self) -> CowStr<'_>;
340}
341
342impl<T> ToCowStr for T
343where
344    T: fmt::Display + ?Sized,
345{
346    fn to_cowstr(&self) -> CowStr<'_> {
347        CowStr::Owned(smol_str::format_smolstr!("{}", self))
348    }
349}
350
351#[cfg(test)]
352mod tests {
353    use super::*;
354
355    #[test]
356    fn test_partialeq_with_str() {
357        let cow_str1 = CowStr::Borrowed("hello");
358        let cow_str2 = CowStr::Borrowed("hello");
359        let cow_str3 = CowStr::Borrowed("world");
360
361        assert_eq!(cow_str1, "hello");
362        assert_eq!("hello", cow_str1);
363        assert_eq!(cow_str1, cow_str2);
364        assert_ne!(cow_str1, "world");
365        assert_ne!("world", cow_str1);
366        assert_ne!(cow_str1, cow_str3);
367    }
368}
jacquard_common/cowstr.rs

jacquard_common/
cowstr.rs
