Add support for smol_str::SmolStr

Cargo.toml

@@ -21,6 +21,7 @@ bytemuck = { version = "1.14", features = [ "min_const_generics", "must_cast" ]
 glam = { version = ">=0.21", default-features = false, optional = true }
 rust_decimal = { version = "1.36", default-features = false, optional = true }
 serde = { version = "1.0", default-features = false, features = [ "alloc" ], optional = true }
+smol_str = { version = "0.3", default-features = false, optional = true }
 time = { version = "0.3", default-features = false, optional = true }
 uuid = { version = "1.10", default-features = false, optional = true }
 
@@ -41,11 +42,11 @@ zstd = "0.13.0"
 
 [features]
 derive = [ "dep:bitcode_derive" ]
-std = [ "serde?/std", "glam?/std", "arrayvec?/std" ]
+std = [ "serde?/std", "glam?/std", "arrayvec?/std", "smol_str?/std" ]
 default = [ "derive", "std" ]
 
 [package.metadata.docs.rs]
-features = [ "derive", "serde", "std" ]
+features = [ "derive", "serde", "smol_str", "std" ]
 
 # TODO halfs speed of benches_borrowed::bench_bitcode_decode
 #[profile.bench]

fuzz/Cargo.toml

@@ -10,10 +10,11 @@ cargo-fuzz = true
 
 [dependencies]
 arrayvec = { version = "0.7", features = ["serde"] }
-bitcode = { path = "..", features = [ "arrayvec", "rust_decimal", "serde", "time" ] }
+bitcode = { path = "..", features = [ "arrayvec", "rust_decimal", "serde", "smol_str", "time" ] }
 libfuzzer-sys = "0.4"
 rust_decimal = "1.36.0"
 serde = { version ="1.0", features = [ "derive" ] }
+smol_str = { version = "0.3", features = ["serde"] }
 time = { version = "0.3", features = ["serde"]}
 
 # Prevent this from interfering with workspaces

fuzz/fuzz_targets/fuzz.rs

@@ -11,6 +11,7 @@ use std::num::NonZeroU32;
 use std::time::Duration;
 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};
 use rust_decimal::Decimal;
+use smol_str::SmolStr;
 
 #[inline(never)]
 fn test_derive<T: Debug + PartialEq + Encode + DecodeOwned>(data: &[u8]) {
@@ -233,5 +234,6 @@ fuzz_target!(|data: &[u8]| {
         SocketAddrV6,
         SocketAddr,
         time::Time,
+        SmolStr,
     );
 });

src/derive/impls.rs

@@ -31,6 +31,8 @@ macro_rules! impl_both {
 impl_both!(bool, BoolEncoder, BoolDecoder);
 impl_both!(f32, F32Encoder, F32Decoder);
 impl_both!(String, StrEncoder, StrDecoder);
+#[cfg(feature = "smol_str")]
+impl_both!(smol_str::SmolStr, StrEncoder, StrDecoder);
 
 macro_rules! impl_int {
     ($($t:ty),+) => {

src/str.rs

@@ -5,7 +5,6 @@ use crate::error::err;
 use crate::fast::{NextUnchecked, SliceImpl};
 use crate::length::LengthDecoder;
 use crate::u8_char::U8Char;
-use alloc::borrow::ToOwned;
 use alloc::string::String;
 use alloc::vec::Vec;
 use core::num::NonZeroUsize;
@@ -57,21 +56,37 @@ impl<'b> Encoder<&'b str> for StrEncoder {
     }
 }
 
-impl Encoder<String> for StrEncoder {
-    #[inline(always)]
-    fn encode(&mut self, t: &String) {
-        self.encode(t.as_str());
-    }
+macro_rules! impl_string {
+    ($t:ty) => {
+        impl crate::coder::Encoder<$t> for crate::str::StrEncoder {
+            #[inline(always)]
+            fn encode(&mut self, t: &$t) {
+                self.encode(t.as_str());
+            }
+
+            #[inline(always)]
+            fn encode_vectored<'a>(&mut self, i: impl Iterator<Item = &'a $t> + Clone)
+            where
+                $t: 'a,
+            {
+                self.encode_vectored(i.map(|s| s.as_str()));
+            }
+        }
 
-    #[inline(always)]
-    fn encode_vectored<'a>(&mut self, i: impl Iterator<Item = &'a String> + Clone)
-    where
-        String: 'a,
-    {
-        self.encode_vectored(i.map(String::as_str));
-    }
+        impl<'a> crate::coder::Decoder<'a, $t> for crate::str::StrDecoder<'a> {
+            #[inline(always)]
+            fn decode(&mut self) -> $t {
+                let v: &str = self.decode();
+                <$t>::from(v)
+            }
+        }
+    };
 }
 
+impl_string!(String);
+#[cfg(feature = "smol_str")]
+impl_string!(smol_str::SmolStr);
+
 // Doesn't use VecDecoder because can't decode &[u8].
 #[derive(Default)]
 pub struct StrDecoder<'a> {
@@ -131,14 +146,6 @@ impl<'a> Decoder<'a, &'a str> for StrDecoder<'a> {
     }
 }
 
-impl<'a> Decoder<'a, String> for StrDecoder<'a> {
-    #[inline(always)]
-    fn decode(&mut self) -> String {
-        let v: &str = self.decode();
-        v.to_owned()
-    }
-}
-
 /// Tests 128 bytes a time instead of `<[u8]>::is_ascii` which only tests 8.
 /// 390% faster on 8KB, 27% faster on 1GB (RAM bottleneck).
 fn is_ascii_simd(v: &[u8]) -> bool {
@@ -288,3 +295,26 @@ mod tests2 {
     }
     crate::bench_encode_decode!(str_vec: Vec<String>);
 }
+
+#[cfg(all(test, feature = "smol_str"))]
+mod smol_str_tests {
+    use smol_str::SmolStr;
+
+    /// Short strings stay inline after decode (no heap allocation).
+    #[test]
+    fn decoded_short_string_is_not_heap_allocated() {
+        let s = SmolStr::new("hello");
+        assert!(!s.is_heap_allocated());
+        let decoded: SmolStr = crate::decode(&crate::encode(&s)).unwrap();
+        assert!(!decoded.is_heap_allocated());
+    }
+
+    /// Long strings are heap-allocated after decode.
+    #[test]
+    fn decoded_long_string_is_heap_allocated() {
+        let s = SmolStr::new("this is a longer string that exceeds inline storage");
+        assert!(s.is_heap_allocated());
+        let decoded: SmolStr = crate::decode(&crate::encode(&s)).unwrap();
+        assert!(decoded.is_heap_allocated());
+    }
+}