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

Provided by KDAB

Privacy Policy