1 | #![cfg_attr (not(feature = "std" ), no_std)] |
2 | #![cfg_attr (docsrs, feature(doc_auto_cfg))] |
3 | |
4 | extern crate alloc; |
5 | |
6 | use alloc::{borrow::Cow, boxed::Box, string::String, sync::Arc}; |
7 | use core::{ |
8 | borrow::Borrow, |
9 | cmp::{self, Ordering}, |
10 | convert::Infallible, |
11 | fmt, hash, iter, mem, ops, |
12 | str::FromStr, |
13 | }; |
14 | |
15 | /// A `SmolStr` is a string type that has the following properties: |
16 | /// |
17 | /// * `size_of::<SmolStr>() == 24` (therefor `== size_of::<String>()` on 64 bit platforms) |
18 | /// * `Clone` is `O(1)` |
19 | /// * Strings are stack-allocated if they are: |
20 | /// * Up to 23 bytes long |
21 | /// * Longer than 23 bytes, but substrings of `WS` (see below). Such strings consist |
22 | /// solely of consecutive newlines, followed by consecutive spaces |
23 | /// * If a string does not satisfy the aforementioned conditions, it is heap-allocated |
24 | /// * Additionally, a `SmolStr` can be explicitly created from a `&'static str` without allocation |
25 | /// |
26 | /// Unlike `String`, however, `SmolStr` is immutable. The primary use case for |
27 | /// `SmolStr` is a good enough default storage for tokens of typical programming |
28 | /// languages. Strings consisting of a series of newlines, followed by a series of |
29 | /// whitespace are a typical pattern in computer programs because of indentation. |
30 | /// Note that a specialized interner might be a better solution for some use cases. |
31 | /// |
32 | /// `WS`: A string of 32 newlines followed by 128 spaces. |
33 | pub struct SmolStr(Repr); |
34 | |
35 | impl SmolStr { |
36 | /// Constructs an inline variant of `SmolStr`. |
37 | /// |
38 | /// This never allocates. |
39 | /// |
40 | /// # Panics |
41 | /// |
42 | /// Panics if `text.len() > 23`. |
43 | #[inline ] |
44 | pub const fn new_inline(text: &str) -> SmolStr { |
45 | assert!(text.len() <= INLINE_CAP); // avoids bounds checks in loop |
46 | |
47 | let text = text.as_bytes(); |
48 | let mut buf = [0; INLINE_CAP]; |
49 | let mut i = 0; |
50 | while i < text.len() { |
51 | buf[i] = text[i]; |
52 | i += 1 |
53 | } |
54 | SmolStr(Repr::Inline { |
55 | // SAFETY: We know that `len` is less than or equal to the maximum value of `InlineSize` |
56 | // as we asserted it. |
57 | len: unsafe { InlineSize::transmute_from_u8(text.len() as u8) }, |
58 | buf, |
59 | }) |
60 | } |
61 | |
62 | /// Constructs a `SmolStr` from a statically allocated string. |
63 | /// |
64 | /// This never allocates. |
65 | #[inline (always)] |
66 | pub const fn new_static(text: &'static str) -> SmolStr { |
67 | // NOTE: this never uses the inline storage; if a canonical |
68 | // representation is needed, we could check for `len() < INLINE_CAP` |
69 | // and call `new_inline`, but this would mean an extra branch. |
70 | SmolStr(Repr::Static(text)) |
71 | } |
72 | |
73 | /// Constructs a `SmolStr` from a `str`, heap-allocating if necessary. |
74 | #[inline (always)] |
75 | pub fn new(text: impl AsRef<str>) -> SmolStr { |
76 | SmolStr(Repr::new(text.as_ref())) |
77 | } |
78 | |
79 | /// Returns a `&str` slice of this `SmolStr`. |
80 | #[inline (always)] |
81 | pub fn as_str(&self) -> &str { |
82 | self.0.as_str() |
83 | } |
84 | |
85 | /// Returns the length of `self` in bytes. |
86 | #[inline (always)] |
87 | pub fn len(&self) -> usize { |
88 | self.0.len() |
89 | } |
90 | |
91 | /// Returns `true` if `self` has a length of zero bytes. |
92 | #[inline (always)] |
93 | pub fn is_empty(&self) -> bool { |
94 | self.0.is_empty() |
95 | } |
96 | |
97 | /// Returns `true` if `self` is heap-allocated. |
98 | #[inline (always)] |
99 | pub const fn is_heap_allocated(&self) -> bool { |
100 | matches!(self.0, Repr::Heap(..)) |
101 | } |
102 | } |
103 | |
104 | impl Clone for SmolStr { |
105 | #[inline ] |
106 | fn clone(&self) -> Self { |
107 | if !self.is_heap_allocated() { |
108 | // SAFETY: We verified that the payload of `Repr` is a POD |
109 | return unsafe { core::ptr::read(self as *const SmolStr) }; |
110 | } |
111 | Self(self.0.clone()) |
112 | } |
113 | } |
114 | |
115 | impl Default for SmolStr { |
116 | #[inline (always)] |
117 | fn default() -> SmolStr { |
118 | SmolStr(Repr::Inline { |
119 | len: InlineSize::_V0, |
120 | buf: [0; INLINE_CAP], |
121 | }) |
122 | } |
123 | } |
124 | |
125 | impl ops::Deref for SmolStr { |
126 | type Target = str; |
127 | |
128 | #[inline (always)] |
129 | fn deref(&self) -> &str { |
130 | self.as_str() |
131 | } |
132 | } |
133 | |
134 | // region: PartialEq implementations |
135 | |
136 | impl Eq for SmolStr {} |
137 | impl PartialEq<SmolStr> for SmolStr { |
138 | fn eq(&self, other: &SmolStr) -> bool { |
139 | self.0.ptr_eq(&other.0) || self.as_str() == other.as_str() |
140 | } |
141 | } |
142 | |
143 | impl PartialEq<str> for SmolStr { |
144 | #[inline (always)] |
145 | fn eq(&self, other: &str) -> bool { |
146 | self.as_str() == other |
147 | } |
148 | } |
149 | |
150 | impl PartialEq<SmolStr> for str { |
151 | #[inline (always)] |
152 | fn eq(&self, other: &SmolStr) -> bool { |
153 | other == self |
154 | } |
155 | } |
156 | |
157 | impl<'a> PartialEq<&'a str> for SmolStr { |
158 | #[inline (always)] |
159 | fn eq(&self, other: &&'a str) -> bool { |
160 | self == *other |
161 | } |
162 | } |
163 | |
164 | impl<'a> PartialEq<SmolStr> for &'a str { |
165 | #[inline (always)] |
166 | fn eq(&self, other: &SmolStr) -> bool { |
167 | *self == other |
168 | } |
169 | } |
170 | |
171 | impl PartialEq<String> for SmolStr { |
172 | #[inline (always)] |
173 | fn eq(&self, other: &String) -> bool { |
174 | self.as_str() == other |
175 | } |
176 | } |
177 | |
178 | impl PartialEq<SmolStr> for String { |
179 | #[inline (always)] |
180 | fn eq(&self, other: &SmolStr) -> bool { |
181 | other == self |
182 | } |
183 | } |
184 | |
185 | impl<'a> PartialEq<&'a String> for SmolStr { |
186 | #[inline (always)] |
187 | fn eq(&self, other: &&'a String) -> bool { |
188 | self == *other |
189 | } |
190 | } |
191 | |
192 | impl<'a> PartialEq<SmolStr> for &'a String { |
193 | #[inline (always)] |
194 | fn eq(&self, other: &SmolStr) -> bool { |
195 | *self == other |
196 | } |
197 | } |
198 | // endregion: PartialEq implementations |
199 | |
200 | impl Ord for SmolStr { |
201 | fn cmp(&self, other: &SmolStr) -> Ordering { |
202 | self.as_str().cmp(other.as_str()) |
203 | } |
204 | } |
205 | |
206 | impl PartialOrd for SmolStr { |
207 | fn partial_cmp(&self, other: &SmolStr) -> Option<Ordering> { |
208 | Some(self.cmp(other)) |
209 | } |
210 | } |
211 | |
212 | impl hash::Hash for SmolStr { |
213 | fn hash<H: hash::Hasher>(&self, hasher: &mut H) { |
214 | self.as_str().hash(state:hasher); |
215 | } |
216 | } |
217 | |
218 | impl fmt::Debug for SmolStr { |
219 | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
220 | fmt::Debug::fmt(self.as_str(), f) |
221 | } |
222 | } |
223 | |
224 | impl fmt::Display for SmolStr { |
225 | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
226 | fmt::Display::fmt(self.as_str(), f) |
227 | } |
228 | } |
229 | |
230 | impl iter::FromIterator<char> for SmolStr { |
231 | fn from_iter<I: iter::IntoIterator<Item = char>>(iter: I) -> SmolStr { |
232 | from_char_iter(iter.into_iter()) |
233 | } |
234 | } |
235 | |
236 | fn from_char_iter(mut iter: impl Iterator<Item = char>) -> SmolStr { |
237 | let (min_size, _) = iter.size_hint(); |
238 | if min_size > INLINE_CAP { |
239 | let heap: String = iter.collect(); |
240 | if heap.len() <= INLINE_CAP { |
241 | // size hint lied |
242 | return SmolStr::new_inline(&heap); |
243 | } |
244 | return SmolStr(Repr::Heap(heap.into_boxed_str().into())); |
245 | } |
246 | let mut len = 0; |
247 | let mut buf = [0u8; INLINE_CAP]; |
248 | while let Some(ch) = iter.next() { |
249 | let size = ch.len_utf8(); |
250 | if size + len > INLINE_CAP { |
251 | let (min_remaining, _) = iter.size_hint(); |
252 | let mut heap = String::with_capacity(size + len + min_remaining); |
253 | heap.push_str(core::str::from_utf8(&buf[..len]).unwrap()); |
254 | heap.push(ch); |
255 | heap.extend(iter); |
256 | return SmolStr(Repr::Heap(heap.into_boxed_str().into())); |
257 | } |
258 | ch.encode_utf8(&mut buf[len..]); |
259 | len += size; |
260 | } |
261 | SmolStr(Repr::Inline { |
262 | // SAFETY: We know that `len` is less than or equal to the maximum value of `InlineSize` |
263 | // as we otherwise return early. |
264 | len: unsafe { InlineSize::transmute_from_u8(len as u8) }, |
265 | buf, |
266 | }) |
267 | } |
268 | |
269 | fn build_from_str_iter<T>(mut iter: impl Iterator<Item = T>) -> SmolStr |
270 | where |
271 | T: AsRef<str>, |
272 | String: iter::Extend<T>, |
273 | { |
274 | let mut len: usize = 0; |
275 | let mut buf: [u8; 23] = [0u8; INLINE_CAP]; |
276 | while let Some(slice: T) = iter.next() { |
277 | let slice: &str = slice.as_ref(); |
278 | let size: usize = slice.len(); |
279 | if size + len > INLINE_CAP { |
280 | let mut heap: String = String::with_capacity(size + len); |
281 | heap.push_str(string:core::str::from_utf8(&buf[..len]).unwrap()); |
282 | heap.push_str(string:slice); |
283 | heap.extend(iter); |
284 | return SmolStr(Repr::Heap(heap.into_boxed_str().into())); |
285 | } |
286 | buf[len..][..size].copy_from_slice(src:slice.as_bytes()); |
287 | len += size; |
288 | } |
289 | SmolStr(Repr::Inline { |
290 | // SAFETY: We know that `len` is less than or equal to the maximum value of `InlineSize` |
291 | // as we otherwise return early. |
292 | len: unsafe { InlineSize::transmute_from_u8(len as u8) }, |
293 | buf, |
294 | }) |
295 | } |
296 | |
297 | impl iter::FromIterator<String> for SmolStr { |
298 | fn from_iter<I: iter::IntoIterator<Item = String>>(iter: I) -> SmolStr { |
299 | build_from_str_iter(iter.into_iter()) |
300 | } |
301 | } |
302 | |
303 | impl<'a> iter::FromIterator<&'a String> for SmolStr { |
304 | fn from_iter<I: iter::IntoIterator<Item = &'a String>>(iter: I) -> SmolStr { |
305 | SmolStr::from_iter(iter.into_iter().map(|x: &'a String| x.as_str())) |
306 | } |
307 | } |
308 | |
309 | impl<'a> iter::FromIterator<&'a str> for SmolStr { |
310 | fn from_iter<I: iter::IntoIterator<Item = &'a str>>(iter: I) -> SmolStr { |
311 | build_from_str_iter(iter.into_iter()) |
312 | } |
313 | } |
314 | |
315 | impl AsRef<str> for SmolStr { |
316 | #[inline (always)] |
317 | fn as_ref(&self) -> &str { |
318 | self.as_str() |
319 | } |
320 | } |
321 | |
322 | impl AsRef<[u8]> for SmolStr { |
323 | #[inline (always)] |
324 | fn as_ref(&self) -> &[u8] { |
325 | self.as_str().as_bytes() |
326 | } |
327 | } |
328 | |
329 | #[cfg (feature = "std" )] |
330 | impl AsRef<std::ffi::OsStr> for SmolStr { |
331 | #[inline (always)] |
332 | fn as_ref(&self) -> &std::ffi::OsStr { |
333 | AsRef::<std::ffi::OsStr>::as_ref(self.as_str()) |
334 | } |
335 | } |
336 | |
337 | #[cfg (feature = "std" )] |
338 | impl AsRef<std::path::Path> for SmolStr { |
339 | #[inline (always)] |
340 | fn as_ref(&self) -> &std::path::Path { |
341 | AsRef::<std::path::Path>::as_ref(self.as_str()) |
342 | } |
343 | } |
344 | |
345 | impl From<&str> for SmolStr { |
346 | #[inline ] |
347 | fn from(s: &str) -> SmolStr { |
348 | SmolStr::new(text:s) |
349 | } |
350 | } |
351 | |
352 | impl From<&mut str> for SmolStr { |
353 | #[inline ] |
354 | fn from(s: &mut str) -> SmolStr { |
355 | SmolStr::new(text:s) |
356 | } |
357 | } |
358 | |
359 | impl From<&String> for SmolStr { |
360 | #[inline ] |
361 | fn from(s: &String) -> SmolStr { |
362 | SmolStr::new(text:s) |
363 | } |
364 | } |
365 | |
366 | impl From<String> for SmolStr { |
367 | #[inline (always)] |
368 | fn from(text: String) -> Self { |
369 | Self::new(text) |
370 | } |
371 | } |
372 | |
373 | impl From<Box<str>> for SmolStr { |
374 | #[inline ] |
375 | fn from(s: Box<str>) -> SmolStr { |
376 | SmolStr::new(text:s) |
377 | } |
378 | } |
379 | |
380 | impl From<Arc<str>> for SmolStr { |
381 | #[inline ] |
382 | fn from(s: Arc<str>) -> SmolStr { |
383 | let repr: Repr = Repr::new_on_stack(text:s.as_ref()).unwrap_or_else(|| Repr::Heap(s)); |
384 | Self(repr) |
385 | } |
386 | } |
387 | |
388 | impl<'a> From<Cow<'a, str>> for SmolStr { |
389 | #[inline ] |
390 | fn from(s: Cow<'a, str>) -> SmolStr { |
391 | SmolStr::new(text:s) |
392 | } |
393 | } |
394 | |
395 | impl From<SmolStr> for Arc<str> { |
396 | #[inline (always)] |
397 | fn from(text: SmolStr) -> Self { |
398 | match text.0 { |
399 | Repr::Heap(data: Arc) => data, |
400 | _ => text.as_str().into(), |
401 | } |
402 | } |
403 | } |
404 | |
405 | impl From<SmolStr> for String { |
406 | #[inline (always)] |
407 | fn from(text: SmolStr) -> Self { |
408 | text.as_str().into() |
409 | } |
410 | } |
411 | |
412 | impl Borrow<str> for SmolStr { |
413 | #[inline (always)] |
414 | fn borrow(&self) -> &str { |
415 | self.as_str() |
416 | } |
417 | } |
418 | |
419 | impl FromStr for SmolStr { |
420 | type Err = Infallible; |
421 | |
422 | #[inline ] |
423 | fn from_str(s: &str) -> Result<SmolStr, Self::Err> { |
424 | Ok(SmolStr::from(s)) |
425 | } |
426 | } |
427 | |
428 | const INLINE_CAP: usize = InlineSize::_V23 as usize; |
429 | const N_NEWLINES: usize = 32; |
430 | const N_SPACES: usize = 128; |
431 | const WS: &str = |
432 | " \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n " ; |
433 | const _: () = { |
434 | assert!(WS.len() == N_NEWLINES + N_SPACES); |
435 | assert!(WS.as_bytes()[N_NEWLINES - 1] == b' \n' ); |
436 | assert!(WS.as_bytes()[N_NEWLINES] == b' ' ); |
437 | }; |
438 | |
439 | /// A [`u8`] with a bunch of niches. |
440 | #[derive (Clone, Copy, Debug, PartialEq)] |
441 | #[repr (u8)] |
442 | enum InlineSize { |
443 | _V0 = 0, |
444 | _V1, |
445 | _V2, |
446 | _V3, |
447 | _V4, |
448 | _V5, |
449 | _V6, |
450 | _V7, |
451 | _V8, |
452 | _V9, |
453 | _V10, |
454 | _V11, |
455 | _V12, |
456 | _V13, |
457 | _V14, |
458 | _V15, |
459 | _V16, |
460 | _V17, |
461 | _V18, |
462 | _V19, |
463 | _V20, |
464 | _V21, |
465 | _V22, |
466 | _V23, |
467 | } |
468 | |
469 | impl InlineSize { |
470 | /// SAFETY: `value` must be less than or equal to [`INLINE_CAP`] |
471 | #[inline (always)] |
472 | const unsafe fn transmute_from_u8(value: u8) -> Self { |
473 | debug_assert!(value <= InlineSize::_V23 as u8); |
474 | // SAFETY: The caller is responsible to uphold this invariant |
475 | unsafe { mem::transmute::<u8, Self>(src:value) } |
476 | } |
477 | } |
478 | |
479 | #[derive (Clone, Debug)] |
480 | enum Repr { |
481 | Inline { |
482 | len: InlineSize, |
483 | buf: [u8; INLINE_CAP], |
484 | }, |
485 | Static(&'static str), |
486 | Heap(Arc<str>), |
487 | } |
488 | |
489 | impl Repr { |
490 | /// This function tries to create a new Repr::Inline or Repr::Static |
491 | /// If it isn't possible, this function returns None |
492 | fn new_on_stack<T>(text: T) -> Option<Self> |
493 | where |
494 | T: AsRef<str>, |
495 | { |
496 | let text = text.as_ref(); |
497 | |
498 | let len = text.len(); |
499 | if len <= INLINE_CAP { |
500 | let mut buf = [0; INLINE_CAP]; |
501 | buf[..len].copy_from_slice(text.as_bytes()); |
502 | return Some(Repr::Inline { |
503 | // SAFETY: We know that `len` is less than or equal to the maximum value of `InlineSize` |
504 | len: unsafe { InlineSize::transmute_from_u8(len as u8) }, |
505 | buf, |
506 | }); |
507 | } |
508 | |
509 | if len <= N_NEWLINES + N_SPACES { |
510 | let bytes = text.as_bytes(); |
511 | let possible_newline_count = cmp::min(len, N_NEWLINES); |
512 | let newlines = bytes[..possible_newline_count] |
513 | .iter() |
514 | .take_while(|&&b| b == b' \n' ) |
515 | .count(); |
516 | let possible_space_count = len - newlines; |
517 | if possible_space_count <= N_SPACES && bytes[newlines..].iter().all(|&b| b == b' ' ) { |
518 | let spaces = possible_space_count; |
519 | let substring = &WS[N_NEWLINES - newlines..N_NEWLINES + spaces]; |
520 | return Some(Repr::Static(substring)); |
521 | } |
522 | } |
523 | None |
524 | } |
525 | |
526 | fn new(text: &str) -> Self { |
527 | Self::new_on_stack(text).unwrap_or_else(|| Repr::Heap(Arc::from(text))) |
528 | } |
529 | |
530 | #[inline (always)] |
531 | fn len(&self) -> usize { |
532 | match self { |
533 | Repr::Heap(data) => data.len(), |
534 | Repr::Static(data) => data.len(), |
535 | Repr::Inline { len, .. } => *len as usize, |
536 | } |
537 | } |
538 | |
539 | #[inline (always)] |
540 | fn is_empty(&self) -> bool { |
541 | match self { |
542 | Repr::Heap(data) => data.is_empty(), |
543 | Repr::Static(data) => data.is_empty(), |
544 | &Repr::Inline { len, .. } => len as u8 == 0, |
545 | } |
546 | } |
547 | |
548 | #[inline ] |
549 | fn as_str(&self) -> &str { |
550 | match self { |
551 | Repr::Heap(data) => data, |
552 | Repr::Static(data) => data, |
553 | Repr::Inline { len, buf } => { |
554 | let len = *len as usize; |
555 | // SAFETY: len is guaranteed to be <= INLINE_CAP |
556 | let buf = unsafe { buf.get_unchecked(..len) }; |
557 | // SAFETY: buf is guaranteed to be valid utf8 for ..len bytes |
558 | unsafe { ::core::str::from_utf8_unchecked(buf) } |
559 | } |
560 | } |
561 | } |
562 | |
563 | fn ptr_eq(&self, other: &Self) -> bool { |
564 | match (self, other) { |
565 | (Self::Heap(l0), Self::Heap(r0)) => Arc::ptr_eq(l0, r0), |
566 | (Self::Static(l0), Self::Static(r0)) => core::ptr::eq(l0, r0), |
567 | ( |
568 | Self::Inline { |
569 | len: l_len, |
570 | buf: l_buf, |
571 | }, |
572 | Self::Inline { |
573 | len: r_len, |
574 | buf: r_buf, |
575 | }, |
576 | ) => l_len == r_len && l_buf == r_buf, |
577 | _ => false, |
578 | } |
579 | } |
580 | } |
581 | |
582 | /// Convert value to [`SmolStr`] using [`fmt::Display`], potentially without allocating. |
583 | /// |
584 | /// Almost identical to [`ToString`], but converts to `SmolStr` instead. |
585 | pub trait ToSmolStr { |
586 | fn to_smolstr(&self) -> SmolStr; |
587 | } |
588 | |
589 | /// [`str`] methods producing [`SmolStr`]s. |
590 | pub trait StrExt: private::Sealed { |
591 | /// Returns the lowercase equivalent of this string slice as a new [`SmolStr`], |
592 | /// potentially without allocating. |
593 | /// |
594 | /// See [`str::to_lowercase`]. |
595 | #[must_use = "this returns a new SmolStr without modifying the original" ] |
596 | fn to_lowercase_smolstr(&self) -> SmolStr; |
597 | |
598 | /// Returns the uppercase equivalent of this string slice as a new [`SmolStr`], |
599 | /// potentially without allocating. |
600 | /// |
601 | /// See [`str::to_uppercase`]. |
602 | #[must_use = "this returns a new SmolStr without modifying the original" ] |
603 | fn to_uppercase_smolstr(&self) -> SmolStr; |
604 | |
605 | /// Returns the ASCII lowercase equivalent of this string slice as a new [`SmolStr`], |
606 | /// potentially without allocating. |
607 | /// |
608 | /// See [`str::to_ascii_lowercase`]. |
609 | #[must_use = "this returns a new SmolStr without modifying the original" ] |
610 | fn to_ascii_lowercase_smolstr(&self) -> SmolStr; |
611 | |
612 | /// Returns the ASCII uppercase equivalent of this string slice as a new [`SmolStr`], |
613 | /// potentially without allocating. |
614 | /// |
615 | /// See [`str::to_ascii_uppercase`]. |
616 | #[must_use = "this returns a new SmolStr without modifying the original" ] |
617 | fn to_ascii_uppercase_smolstr(&self) -> SmolStr; |
618 | |
619 | /// Replaces all matches of a &str with another &str returning a new [`SmolStr`], |
620 | /// potentially without allocating. |
621 | /// |
622 | /// See [`str::replace`]. |
623 | #[must_use = "this returns a new SmolStr without modifying the original" ] |
624 | fn replace_smolstr(&self, from: &str, to: &str) -> SmolStr; |
625 | |
626 | /// Replaces first N matches of a &str with another &str returning a new [`SmolStr`], |
627 | /// potentially without allocating. |
628 | /// |
629 | /// See [`str::replacen`]. |
630 | #[must_use = "this returns a new SmolStr without modifying the original" ] |
631 | fn replacen_smolstr(&self, from: &str, to: &str, count: usize) -> SmolStr; |
632 | } |
633 | |
634 | impl StrExt for str { |
635 | #[inline ] |
636 | fn to_lowercase_smolstr(&self) -> SmolStr { |
637 | from_char_iter(self.chars().flat_map(|c| c.to_lowercase())) |
638 | } |
639 | |
640 | #[inline ] |
641 | fn to_uppercase_smolstr(&self) -> SmolStr { |
642 | from_char_iter(self.chars().flat_map(|c| c.to_uppercase())) |
643 | } |
644 | |
645 | #[inline ] |
646 | fn to_ascii_lowercase_smolstr(&self) -> SmolStr { |
647 | from_char_iter(self.chars().map(|c| c.to_ascii_lowercase())) |
648 | } |
649 | |
650 | #[inline ] |
651 | fn to_ascii_uppercase_smolstr(&self) -> SmolStr { |
652 | from_char_iter(self.chars().map(|c| c.to_ascii_uppercase())) |
653 | } |
654 | |
655 | #[inline ] |
656 | fn replace_smolstr(&self, from: &str, to: &str) -> SmolStr { |
657 | self.replacen_smolstr(from, to, usize::MAX) |
658 | } |
659 | |
660 | #[inline ] |
661 | fn replacen_smolstr(&self, from: &str, to: &str, count: usize) -> SmolStr { |
662 | let mut result = SmolStrBuilder::new(); |
663 | let mut last_end = 0; |
664 | for (start, part) in self.match_indices(from).take(count) { |
665 | // SAFETY: `start` is guaranteed to be within the bounds of `self` as per |
666 | // `match_indices` and last_end is always less than or equal to `start` |
667 | result.push_str(unsafe { self.get_unchecked(last_end..start) }); |
668 | result.push_str(to); |
669 | last_end = start + part.len(); |
670 | } |
671 | // SAFETY: `self.len()` is guaranteed to be within the bounds of `self` and last_end is |
672 | // always less than or equal to `self.len()` |
673 | result.push_str(unsafe { self.get_unchecked(last_end..self.len()) }); |
674 | SmolStr::from(result) |
675 | } |
676 | } |
677 | |
678 | impl<T> ToSmolStr for T |
679 | where |
680 | T: fmt::Display + ?Sized, |
681 | { |
682 | fn to_smolstr(&self) -> SmolStr { |
683 | format_smolstr!(" {}" , self) |
684 | } |
685 | } |
686 | |
687 | mod private { |
688 | /// No downstream impls allowed. |
689 | pub trait Sealed {} |
690 | impl Sealed for str {} |
691 | } |
692 | |
693 | /// Formats arguments to a [`SmolStr`], potentially without allocating. |
694 | /// |
695 | /// See [`alloc::format!`] or [`format_args!`] for syntax documentation. |
696 | #[macro_export ] |
697 | macro_rules! format_smolstr { |
698 | ($($tt:tt)*) => {{ |
699 | let mut w = $crate::SmolStrBuilder::new(); |
700 | ::core::fmt::Write::write_fmt(&mut w, format_args!($($tt)*)).expect("a formatting trait implementation returned an error" ); |
701 | w.finish() |
702 | }}; |
703 | } |
704 | |
705 | /// A builder that can be used to efficiently build a [`SmolStr`]. |
706 | /// |
707 | /// This won't allocate if the final string fits into the inline buffer. |
708 | #[derive (Clone, Default, Debug, PartialEq, Eq)] |
709 | pub struct SmolStrBuilder(SmolStrBuilderRepr); |
710 | |
711 | #[derive (Clone, Debug, PartialEq, Eq)] |
712 | enum SmolStrBuilderRepr { |
713 | Inline { len: usize, buf: [u8; INLINE_CAP] }, |
714 | Heap(String), |
715 | } |
716 | |
717 | impl Default for SmolStrBuilderRepr { |
718 | #[inline ] |
719 | fn default() -> Self { |
720 | SmolStrBuilderRepr::Inline { |
721 | buf: [0; INLINE_CAP], |
722 | len: 0, |
723 | } |
724 | } |
725 | } |
726 | |
727 | impl SmolStrBuilder { |
728 | /// Creates a new empty [`SmolStrBuilder`]. |
729 | #[must_use ] |
730 | pub const fn new() -> Self { |
731 | Self(SmolStrBuilderRepr::Inline { |
732 | buf: [0; INLINE_CAP], |
733 | len: 0, |
734 | }) |
735 | } |
736 | |
737 | /// Builds a [`SmolStr`] from `self`. |
738 | #[must_use ] |
739 | pub fn finish(&self) -> SmolStr { |
740 | SmolStr(match &self.0 { |
741 | &SmolStrBuilderRepr::Inline { len, buf } => { |
742 | debug_assert!(len <= INLINE_CAP); |
743 | Repr::Inline { |
744 | // SAFETY: We know that `value.len` is less than or equal to the maximum value of `InlineSize` |
745 | len: unsafe { InlineSize::transmute_from_u8(len as u8) }, |
746 | buf, |
747 | } |
748 | } |
749 | SmolStrBuilderRepr::Heap(heap) => Repr::new(heap), |
750 | }) |
751 | } |
752 | |
753 | /// Appends the given [`char`] to the end of `self`'s buffer. |
754 | pub fn push(&mut self, c: char) { |
755 | match &mut self.0 { |
756 | SmolStrBuilderRepr::Inline { len, buf } => { |
757 | let char_len = c.len_utf8(); |
758 | let new_len = *len + char_len; |
759 | if new_len <= INLINE_CAP { |
760 | c.encode_utf8(&mut buf[*len..]); |
761 | *len += char_len; |
762 | } else { |
763 | let mut heap = String::with_capacity(new_len); |
764 | // copy existing inline bytes over to the heap |
765 | // SAFETY: inline data is guaranteed to be valid utf8 for `old_len` bytes |
766 | unsafe { heap.as_mut_vec().extend_from_slice(&buf[..*len]) }; |
767 | heap.push(c); |
768 | self.0 = SmolStrBuilderRepr::Heap(heap); |
769 | } |
770 | } |
771 | SmolStrBuilderRepr::Heap(h) => h.push(c), |
772 | } |
773 | } |
774 | |
775 | /// Appends a given string slice onto the end of `self`'s buffer. |
776 | pub fn push_str(&mut self, s: &str) { |
777 | match &mut self.0 { |
778 | SmolStrBuilderRepr::Inline { len, buf } => { |
779 | let old_len = *len; |
780 | *len += s.len(); |
781 | |
782 | // if the new length will fit on the stack (even if it fills it entirely) |
783 | if *len <= INLINE_CAP { |
784 | buf[old_len..*len].copy_from_slice(s.as_bytes()); |
785 | return; // skip the heap push below |
786 | } |
787 | |
788 | let mut heap = String::with_capacity(*len); |
789 | |
790 | // copy existing inline bytes over to the heap |
791 | // SAFETY: inline data is guaranteed to be valid utf8 for `old_len` bytes |
792 | unsafe { heap.as_mut_vec().extend_from_slice(&buf[..old_len]) }; |
793 | heap.push_str(s); |
794 | self.0 = SmolStrBuilderRepr::Heap(heap); |
795 | } |
796 | SmolStrBuilderRepr::Heap(heap) => heap.push_str(s), |
797 | } |
798 | } |
799 | } |
800 | |
801 | impl fmt::Write for SmolStrBuilder { |
802 | #[inline ] |
803 | fn write_str(&mut self, s: &str) -> fmt::Result { |
804 | self.push_str(s); |
805 | Ok(()) |
806 | } |
807 | } |
808 | |
809 | impl From<SmolStrBuilder> for SmolStr { |
810 | fn from(value: SmolStrBuilder) -> Self { |
811 | value.finish() |
812 | } |
813 | } |
814 | |
815 | #[cfg (feature = "arbitrary" )] |
816 | impl<'a> arbitrary::Arbitrary<'a> for SmolStr { |
817 | fn arbitrary(u: &mut arbitrary::Unstructured<'a>) -> Result<Self, arbitrary::Error> { |
818 | let s = <&str>::arbitrary(u)?; |
819 | Ok(SmolStr::new(s)) |
820 | } |
821 | } |
822 | |
823 | #[cfg (feature = "borsh" )] |
824 | mod borsh; |
825 | #[cfg (feature = "serde" )] |
826 | mod serde; |
827 | |